From: Churchill Khangar <churchill.khangar@intel.com>
To: dts@dpdk.org
Cc: cristian.dumitrescu@intel.com, venkata.suresh.kumar.p@intel.com,
churchill.khangar@intel.com, yogesh.jangra@intel.com
Subject: [dts] [PATCH 2/2] tests/pipeline: add new features test coverage
Date: Wed, 21 Apr 2021 06:17:14 -0400 [thread overview]
Message-ID: <1619000234-46133-3-git-send-email-churchill.khangar@intel.com> (raw)
In-Reply-To: <1619000234-46133-1-git-send-email-churchill.khangar@intel.com>
This patch has the pipeline test suite changes to cover
the new features and enhancements to existing tests.
Following are the details of new features and
existing test cases enhancements
1. Framework enhancements to improve overall execution time.
2. RING I/O port type
3. WCM table match
4. Register Array
5. trTCM
6. Enhancement to existing test cases to verify
a. Endianness issue
b. Operands with variable size values
7. Additional tests to provide more coverage for table match and actions
8. Additional tests to cover customer common use cases
Signed-off-by: Churchill Khangar <churchill.khangar@intel.com>
Signed-off-by: Yogesh Jangra <yogesh.jangra@intel.com>
Tested-by: Venkata Suresh Kumar P <venkata.suresh.kumar.p@intel.com>
---
tests/TestSuite_pipeline.py | 8416 +++++++++++++++++++------------------------
1 file changed, 3661 insertions(+), 4755 deletions(-)
diff --git a/tests/TestSuite_pipeline.py b/tests/TestSuite_pipeline.py
index 9597896..d1f4d50 100644
--- a/tests/TestSuite_pipeline.py
+++ b/tests/TestSuite_pipeline.py
@@ -65,12 +65,17 @@ from scapy.sendrecv import sendp
import itertools
+MODE = 1 # 0: Development, 1: Release
+
TIMESTAMP = re.compile(r'\d{2}\:\d{2}\:\d{2}\.\d{6}')
PAYLOAD = re.compile(r'\t0x([0-9a-fA-F]+): ([0-9a-fA-F ]+)')
FILE_DIR = os.path.dirname(os.path.abspath(__file__)).split(os.path.sep)
DEP_DIR = os.path.sep.join(FILE_DIR[:-1]) + '/dep/'
+BUFFER_SIZE = 1024
+CLI_SERVER_CONNECT_DELAY = 1
+
class TestPipeline(TestCase):
@@ -200,9 +205,52 @@ class TestPipeline(TestCase):
self.convert_tcpdump_to_text2pcap('/tmp/packet_rx.txt', '/tmp/packet_rx_rcv.txt')
out = self.tester.send_command(
'diff -sqw /tmp/packet_rx_rcv.txt {}'.format('/tmp/' + out_pcap_file), timeout=0.5)
- if "differ" in out:
+ if "are identical" not in out:
+ self.dut.send_expect('^C', '# ')
+ self.verify(False, "Output pcap files mismatch error")
+
+ def send_and_sniff_multiple(self, from_port, to_port, in_pcap, out_pcap, filters, rate=0):
+
+ self.tester.send_expect('rm -f /tmp/*.txt /tmp/*.pcap /tmp/*.out', '# ')
+ tx_count = len(from_port)
+ rx_count = len(to_port)
+ tx_port, rx_port, tx_inf, rx_inf = ([] for i in range(4))
+
+ for i in range(tx_count):
+ tx_port.append(self.tester.get_local_port(self.dut_ports[from_port[i]]))
+ tx_inf.append(self.tester.get_interface(tx_port[i]))
+
+ for i in range(rx_count):
+ rx_port.append(self.tester.get_local_port(self.dut_ports[to_port[i]]))
+ rx_inf.append(self.tester.get_interface(rx_port[i]))
+ self.tcpdump_start_sniff(rx_inf[i], filters[i])
+
+ self.tester.scapy_foreground()
+ for i in range(tx_count):
+ self.tester.send_expect(
+ 'text2pcap -q {} /tmp/tx_{}.pcap'.format('/tmp/' + in_pcap[i], tx_inf[i]), '# ')
+ self.tester.scapy_append('pkt = rdpcap("/tmp/tx_{}.pcap")'.format(tx_inf[i]))
+ if rate:
+ self.tester.scapy_append(
+ 'sendp(pkt, iface="{}", count=1, inter=1./{})'.format(tx_inf[i], rate))
+ else:
+ self.tester.scapy_append('sendp(pkt, iface="{}", count=1)'.format(tx_inf[i]))
+
+ self.tester.scapy_execute()
+ self.tcpdump_stop_sniff()
+ mismatch_count = 0
+ for i in range(rx_count):
+ self.tester.send_expect(
+ 'tcpdump -n -r /tmp/tcpdump_{}.pcap -xx > /tmp/packet_rx.txt'.format(rx_inf[i]), '# ')
+ self.convert_tcpdump_to_text2pcap(
+ '/tmp/packet_rx.txt', '/tmp/packet_rx_rcv_{}.txt'.format(rx_inf[i]))
+ cmd = 'diff -sqw /tmp/packet_rx_rcv_{}.txt {}'.format(rx_inf[i], '/tmp/' + out_pcap[i])
+ out = self.tester.send_command(cmd, timeout=0.5)
+ if "are identical" not in out:
+ mismatch_count += 1
+ if mismatch_count:
self.dut.send_expect('^C', '# ')
- self.verify("are identical" in out, "Output pcap files mismatch error")
+ self.verify(False, "Output pcap files mismatch error")
def setup_env(self, port_nums, driver):
"""
@@ -279,7 +327,7 @@ class TestPipeline(TestCase):
self.vf3_mac = "00:11:22:33:44:58"
ports = [self.dut_p0_pci, self.dut_p1_pci, self.dut_p2_pci, self.dut_p3_pci]
- self.eal_para = self.dut.create_eal_parameters(cores=list(range(2)), ports=ports)
+ self.eal_para = self.dut.create_eal_parameters(cores=list(range(4)), ports=ports)
self.sriov_vfs_port = []
self.session_secondary = self.dut.new_session()
@@ -289,10 +337,13 @@ class TestPipeline(TestCase):
self.app_testpmd_path = self.dut.apps_name['test-pmd']
self.param_flow_dir = self.get_flow_direction_param_of_tcpdump()
- # update the ./dep/pipeline.tar.gz file for any new changes
- P4_PIPILINE_TAR_FILE = DEP_DIR + 'pipeline.tar.gz'
+ # update the ./dep/pipeline.tar.gz file
+ PIPELINE_TAR_FILE = DEP_DIR + 'pipeline.tar.gz'
self.tester.send_expect('rm -rf /tmp/pipeline', '# ')
- self.tester.send_expect('tar -zxf {} --directory /tmp'.format(P4_PIPILINE_TAR_FILE), "# ", 20)
+ if MODE == 0: # Development
+ self.tester.send_expect('rm -rf {}'.format(PIPELINE_TAR_FILE), '# ')
+ self.tester.send_expect('tar -czf {} -C {} pipeline/'.format(PIPELINE_TAR_FILE, DEP_DIR), '# ')
+ self.tester.send_expect('tar -zxf {} --directory /tmp'.format(PIPELINE_TAR_FILE), "# ", 20)
# copy the ./dep/pipeline.tar.gz file to DUT
self.dut.send_expect('rm -rf /tmp/pipeline.tar.gz /tmp/pipeline', "# ", 20)
@@ -305,47 +356,44 @@ class TestPipeline(TestCase):
"""
pass
- def test_rx_tx_001(self):
- """
- rx_tx_001: revert the received packet on the same port without any change
- """
- cli_file = '/tmp/pipeline/rx_tx_001/rx_tx_001.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/rx_tx_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/rx_tx_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ def connect_cli_server(self):
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ SERVER_IP = '192.168.122.216'
+ SERVER_PORT = 8086
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ try:
+ s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ try:
+ s.connect((SERVER_IP, SERVER_PORT))
+ sleep(1)
+ msg = s.recv(BUFFER_SIZE)
+ response = msg.decode()
+ # print('Rxd: ' + response)
+ if "pipeline>" not in response:
+ s.close()
+ self.verify(0, "CLI Response Error")
+ else:
+ return s
+ except socket.error as err:
+ print("Socket connection failed with error %s" % (err))
+ self.verify(0, "Failed to connect to server")
+ except socket.error as err:
+ print("Socket creation failed with error %s" % (err))
+ self.verify(0, "Failed to create socket")
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ def socket_send_cmd(self, socket, cmd, expected_rsp):
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ socket.send(cmd.encode('utf-8'))
+ 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)
+ self.verify(0, "CLI Response Error")
- def test_extract_emit_001(self):
- """
- extract_emit_001: revert the received packet on the same port without any change
- """
- cli_file = '/tmp/pipeline/extract_emit_001/extract_emit_001.cli'
+ def run_dpdk_app(self, cli_file):
cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
self.dut.send_expect(cmd, "# ", 20)
@@ -355,5249 +403,4107 @@ class TestPipeline(TestCase):
self.dut.send_expect(cmd, "# ", 20)
cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
self.dut.send_expect(cmd, "# ", 20)
-
cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/extract_emit_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/extract_emit_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ self.dut.send_expect(cmd, "PIPELINE0 enable", 75)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ def send_pkts(self, from_port, to_port, in_pcap_file):
+ """
+ Send pkts read from the input pcap file.
+ """
+ tx_port = self.tester.get_local_port(self.dut_ports[from_port])
+ rx_port = self.tester.get_local_port(self.dut_ports[to_port])
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ tx_interface = self.tester.get_interface(tx_port)
+ rx_interface = self.tester.get_interface(rx_port)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ self.tester.send_expect('rm -f /tmp/*.txt /tmp/*.pcap /tmp/*.out', '# ')
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ # Prepare the pkts to be sent
+ self.tester.scapy_foreground()
+ self.tester.send_expect('text2pcap -q {} /tmp/packet_tx.pcap'.format('/tmp/' + in_pcap_file), '# ')
+ self.tester.scapy_append('pkt = rdpcap("/tmp/packet_tx.pcap")')
+ self.tester.scapy_append('sendp(pkt, iface="{}", count=1)'.format(tx_interface))
+ self.tester.scapy_execute()
- def test_extract_emit_002(self):
+ def test_rx_tx_001(self):
- cli_file = '/tmp/pipeline/extract_emit_002/extract_emit_002.cli'
+ cli_file = '/tmp/pipeline/rx_tx_001/rx_tx_001.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/rx_tx_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/rx_tx_001/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_extract_emit_001(self):
- # rule 0 test
- in_pcap_file = 'pipeline/extract_emit_002/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/extract_emit_002/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/extract_emit_001/extract_emit_001.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/extract_emit_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/extract_emit_001/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_extract_emit_002(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/extract_emit_002/extract_emit_002.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/extract_emit_002/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/extract_emit_002/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_extract_emit_003(self):
cli_file = '/tmp/pipeline/extract_emit_003/extract_emit_003.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/extract_emit_003/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/extract_emit_003/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_extract_emit_004(self):
- # rule 0 test
- in_pcap_file = 'pipeline/extract_emit_003/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/extract_emit_003/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/extract_emit_004/extract_emit_004.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/extract_emit_004/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/extract_emit_004/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_extract_emit_005(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/extract_emit_005/extract_emit_005.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/extract_emit_005/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/extract_emit_005/pcap_files/out_1.txt'] * 4
+ filters = ["vlan"] * 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_004(self):
+ def test_extract_emit_006(self):
- cli_file = '/tmp/pipeline/extract_emit_004/extract_emit_004.cli'
+ cli_file = '/tmp/pipeline/extract_emit_006/extract_emit_006.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/extract_emit_006/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/extract_emit_006/pcap_files/out_1.txt'] * 4
+ filters = ["udp port 4789"] * 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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_extract_emit_007(self):
- # rule 0 test
- in_pcap_file = 'pipeline/extract_emit_004/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/extract_emit_004/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/extract_emit_007/extract_emit_007.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/extract_emit_007/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/extract_emit_007/pcap_files/out_1.txt'] * 4
+ filters = ["udp port 4789"] * 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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_extract_emit_008(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/extract_emit_008/extract_emit_008.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/extract_emit_008/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/extract_emit_008/pcap_files/out_1.txt'] * 4
+ filters = ["udp port 4789"] * 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_005(self):
+ def test_extract_emit_009(self):
- cli_file = '/tmp/pipeline/extract_emit_005/extract_emit_005.cli'
+ cli_file = '/tmp/pipeline/extract_emit_009/extract_emit_009.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/extract_emit_009/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/extract_emit_009/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_and_001(self):
- # rule 0 test
- in_pcap_file = 'pipeline/extract_emit_005/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/extract_emit_005/pcap_files/out_1.txt'
- filters = "vlan"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/and_001/and_001.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/and_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/and_001/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_and_002(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/and_002/and_002.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = 'pipeline/and_002/pcap_files/in_1.txt'
+ out_pcap = 'pipeline/and_002/pcap_files/out_1.txt'
+ self.send_and_sniff_pkts(0, 0, in_pcap, out_pcap, "tcp")
+ self.send_and_sniff_pkts(1, 0, in_pcap, out_pcap, "tcp")
+ self.send_and_sniff_pkts(2, 0, in_pcap, out_pcap, "tcp")
+ self.send_and_sniff_pkts(3, 0, in_pcap, out_pcap, "tcp")
+ self.dut.send_expect("^C", "# ", 20)
- def test_extract_emit_006(self):
+ def test_and_003(self):
- cli_file = '/tmp/pipeline/extract_emit_006/extract_emit_006.cli'
+ cli_file = '/tmp/pipeline/and_003/and_003.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/and_003/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/and_003/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_and_004(self):
- # rule 0 test
- in_pcap_file = 'pipeline/extract_emit_006/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/extract_emit_006/pcap_files/out_1.txt'
- filters = "udp port 4789"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/and_004/and_004.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/and_004/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/and_004/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_and_005(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/and_005/and_005.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/and_005/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/and_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_extract_emit_007(self):
+ def test_and_006(self):
- cli_file = '/tmp/pipeline/extract_emit_007/extract_emit_007.cli'
+ cli_file = '/tmp/pipeline/and_006/and_006.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/and_006/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/and_006/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_and_007(self):
- # rule 0 test
- in_pcap_file = 'pipeline/extract_emit_007/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/extract_emit_007/pcap_files/out_1.txt'
- filters = "udp port 4789"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/and_007/and_007.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/and_007/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/and_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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_and_008(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/and_008/and_008.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/and_008/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/and_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)
+ self.dut.send_expect("^C", "# ", 20)
- def test_extract_emit_008(self):
+ def test_or_001(self):
- cli_file = '/tmp/pipeline/extract_emit_008/extract_emit_008.cli'
+ cli_file = '/tmp/pipeline/or_001/or_001.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/or_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/or_001/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_or_002(self):
- # rule 0 test
- in_pcap_file = 'pipeline/extract_emit_008/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/extract_emit_008/pcap_files/out_1.txt'
- filters = "udp port 4789"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/or_002/or_002.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/or_002/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/or_002/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_or_003(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/or_003/or_003.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/or_003/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/or_003/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_extract_emit_009(self):
+ def test_or_004(self):
- cli_file = '/tmp/pipeline/extract_emit_009/extract_emit_009.cli'
+ cli_file = '/tmp/pipeline/or_004/or_004.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/or_004/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/or_004/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_or_005(self):
- # rule 0 test
- in_pcap_file = 'pipeline/extract_emit_009/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/extract_emit_009/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/or_005/or_005.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/or_005/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/or_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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_or_006(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/or_006/or_006.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/or_006/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/or_006/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_and_001(self):
+ def test_or_007(self):
- cli_file = '/tmp/pipeline/and_001/and_001.cli'
+ cli_file = '/tmp/pipeline/or_007/or_007.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/or_007/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/or_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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_or_008(self):
- # rule 0 test
- in_pcap_file = 'pipeline/and_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/and_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/or_008/or_008.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = 'pipeline/or_008/pcap_files/in_1.txt'
+ out_pcap = 'pipeline/or_008/pcap_files/out_1.txt'
+ self.send_and_sniff_pkts(0, 1, in_pcap, out_pcap, "tcp")
+ self.send_and_sniff_pkts(1, 1, in_pcap, out_pcap, "tcp")
+ self.send_and_sniff_pkts(2, 3, in_pcap, out_pcap, "tcp")
+ self.send_and_sniff_pkts(3, 3, in_pcap, out_pcap, "tcp")
+ self.dut.send_expect("^C", "# ", 20)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_xor_001(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/xor_001/xor_001.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/xor_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/xor_001/pcap_files/out_1.txt'] * 4
+ filters = ["tcp"] * 4
+ tx_port = [0, 1, 2, 3]
+ rx_port = [1, 0, 3, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+ self.dut.send_expect("^C", "# ", 20)
- def test_and_002(self):
+ def test_xor_002(self):
- cli_file = '/tmp/pipeline/and_002/and_002.cli'
+ cli_file = '/tmp/pipeline/xor_002/xor_002.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/xor_002/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/xor_002/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_xor_003(self):
- # rule 0 test
- in_pcap_file = 'pipeline/and_002/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/and_002/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/xor_003/xor_003.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 0, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/xor_003/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/xor_003/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 0, in_pcap_file, out_pcap_file, filters)
+ def test_xor_004(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/xor_004/xor_004.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/xor_004/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/xor_004/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_and_003(self):
+ def test_xor_005(self):
- cli_file = '/tmp/pipeline/and_003/and_003.cli'
+ cli_file = '/tmp/pipeline/xor_005/xor_005.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/xor_005/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/xor_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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_xor_006(self):
- # rule 0 test
- in_pcap_file = 'pipeline/and_003/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/and_003/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/xor_006/xor_006.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/xor_006/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/xor_006/pcap_files/out_1.txt'] * 4
+ filters = ["tcp"] * 4
+ tx_port = [0, 1, 2, 3]
+ rx_port = [1, 0, 3, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+ self.dut.send_expect("^C", "# ", 20)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_xor_007(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/xor_007/xor_007.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/xor_007/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/xor_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_and_004(self):
+ def test_xor_008(self):
- cli_file = '/tmp/pipeline/and_004/and_004.cli'
+ cli_file = '/tmp/pipeline/xor_008/xor_008.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/xor_008/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/xor_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)
+ self.dut.send_expect("^C", "# ", 20)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_add_001(self):
- # rule 0 test
- in_pcap_file = 'pipeline/and_004/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/and_004/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/add_001/add_001.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/add_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/add_001/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_add_002(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/add_002/add_002.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/add_002/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/add_002/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_and_005(self):
+ def test_add_003(self):
- cli_file = '/tmp/pipeline/and_005/and_005.cli'
+ cli_file = '/tmp/pipeline/add_003/add_003.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/add_003/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/add_003/pcap_files/out_1.txt'] * 4
+ filters = ["tcp"] * 4
+ tx_port = [0, 1, 2]
+ rx_port = [1, 2, 3]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+ self.dut.send_expect("^C", "# ", 20)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_add_004(self):
- # rule 0 test
- in_pcap_file = 'pipeline/and_005/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/and_005/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/add_004/add_004.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/add_004/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/add_004/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_add_005(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/add_005/add_005.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/add_005/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/add_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_and_006(self):
+ def test_add_006(self):
- cli_file = '/tmp/pipeline/and_006/and_006.cli'
+ cli_file = '/tmp/pipeline/add_006/add_006.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/add_006/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/add_006/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_add_007(self):
- # rule 0 test
- in_pcap_file = 'pipeline/and_006/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/and_006/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/add_007/add_007.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/add_007/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/add_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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_add_008(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/add_008/add_008.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/add_008/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/add_008/pcap_files/out_1.txt'] * 4
+ filters = ["udp"] * 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_007(self):
+ def test_shl_001(self):
- cli_file = '/tmp/pipeline/and_007/and_007.cli'
+ cli_file = '/tmp/pipeline/shl_001/shl_001.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/shl_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/shl_001/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_shl_002(self):
- # rule 0 test
- in_pcap_file = 'pipeline/and_007/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/and_007/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/shl_002/shl_002.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/shl_002/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/shl_002/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_shl_003(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/shl_003/shl_003.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/shl_003/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/shl_003/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_and_008(self):
+ def test_shl_004(self):
- cli_file = '/tmp/pipeline/and_008/and_008.cli'
+ cli_file = '/tmp/pipeline/shl_004/shl_004.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/shl_004/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/shl_004/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_shl_005(self):
- # rule 0 test
- in_pcap_file = 'pipeline/and_008/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/and_008/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/shl_005/shl_005.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/shl_005/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/shl_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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_shl_006(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/shl_006/shl_006.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/shl_006/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/shl_006/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_or_001(self):
+ def test_shl_007(self):
- cli_file = '/tmp/pipeline/or_001/or_001.cli'
+ cli_file = '/tmp/pipeline/shl_007/shl_007.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/shl_007/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/shl_007/pcap_files/out_1.txt'] * 4
+ filters = ["udp"] * 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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_shl_008(self):
- # rule 0 test
- in_pcap_file = 'pipeline/or_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/or_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/shl_008/shl_008.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/shl_008/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/shl_008/pcap_files/out_1.txt'] * 4
+ filters = ["udp"] * 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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_shr_001(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/shr_001/shr_001.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/shr_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/shr_001/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_or_002(self):
+ def test_shr_002(self):
- cli_file = '/tmp/pipeline/or_002/or_002.cli'
+ cli_file = '/tmp/pipeline/shr_002/shr_002.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/shr_002/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/shr_002/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_shr_003(self):
- # rule 0 test
- in_pcap_file = 'pipeline/or_002/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/or_002/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/shr_003/shr_003.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/shr_003/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/shr_003/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_shr_004(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/shr_004/shr_004.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/shr_004/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/shr_004/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_or_003(self):
+ def test_shr_005(self):
- cli_file = '/tmp/pipeline/or_003/or_003.cli'
+ cli_file = '/tmp/pipeline/shr_005/shr_005.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/shr_005/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/shr_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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_shr_006(self):
- # rule 0 test
- in_pcap_file = 'pipeline/or_003/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/or_003/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/shr_006/shr_006.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/shr_006/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/shr_006/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_shr_007(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/shr_007/shr_007.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/shr_007/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/shr_007/pcap_files/out_1.txt'] * 4
+ filters = ["udp"] * 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_or_004(self):
+ def test_shr_008(self):
- cli_file = '/tmp/pipeline/or_004/or_004.cli'
+ cli_file = '/tmp/pipeline/shr_008/shr_008.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/shr_008/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/shr_008/pcap_files/out_1.txt'] * 4
+ filters = ["udp"] * 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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_sub_001(self):
- # rule 0 test
- in_pcap_file = 'pipeline/or_004/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/or_004/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/sub_001/sub_001.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/sub_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/sub_001/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_sub_002(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/sub_002/sub_002.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/sub_002/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/sub_002/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_or_005(self):
+ def test_sub_003(self):
- cli_file = '/tmp/pipeline/or_005/or_005.cli'
+ cli_file = '/tmp/pipeline/sub_003/sub_003.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/sub_003/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/sub_003/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_sub_004(self):
- # rule 0 test
- in_pcap_file = 'pipeline/or_005/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/or_005/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/sub_004/sub_004.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/sub_004/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/sub_004/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_sub_005(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/sub_005/sub_005.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/sub_005/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/sub_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_or_006(self):
+ def test_sub_006(self):
- cli_file = '/tmp/pipeline/or_006/or_006.cli'
+ cli_file = '/tmp/pipeline/sub_006/sub_006.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/sub_006/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/sub_006/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_sub_007(self):
- # rule 0 test
- in_pcap_file = 'pipeline/or_006/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/or_006/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/sub_007/sub_007.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/sub_007/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/sub_007/pcap_files/out_1.txt'] * 4
+ filters = ["udp"] * 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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_sub_008(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/sub_008/sub_008.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/sub_008/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/sub_008/pcap_files/out_1.txt'] * 4
+ filters = ["udp"] * 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_or_007(self):
+ def test_mov_001(self):
- cli_file = '/tmp/pipeline/or_007/or_007.cli'
+ cli_file = '/tmp/pipeline/mov_001/mov_001.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/mov_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/mov_001/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_mov_002(self):
- # rule 0 test
- in_pcap_file = 'pipeline/or_007/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/or_007/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/mov_002/mov_002.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/mov_002/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/mov_002/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_mov_003(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/mov_003/mov_003.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/mov_003/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/mov_003/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_or_008(self):
+ def test_mov_004(self):
- cli_file = '/tmp/pipeline/or_008/or_008.cli'
+ cli_file = '/tmp/pipeline/mov_004/mov_004.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/mov_004/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/mov_004/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_mov_005(self):
- # rule 0 test
- in_pcap_file = 'pipeline/or_008/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/or_008/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 1, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/mov_005/mov_005.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = 'pipeline/mov_005/pcap_files/in_1.txt'
+ out_pcap = 'pipeline/mov_005/pcap_files/out_1.txt'
+ self.send_and_sniff_pkts(0, 0, in_pcap, out_pcap, "tcp")
+ self.send_and_sniff_pkts(1, 0, in_pcap, out_pcap, "tcp")
+ self.send_and_sniff_pkts(2, 0, in_pcap, out_pcap, "tcp")
+ self.send_and_sniff_pkts(3, 0, in_pcap, out_pcap, "tcp")
+ self.dut.send_expect("^C", "# ", 20)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 3, in_pcap_file, out_pcap_file, filters)
+ def test_mov_007(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/mov_007/mov_007.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/mov_007/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/mov_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_xor_001(self):
+ def test_mov_008(self):
- cli_file = '/tmp/pipeline/xor_001/xor_001.cli'
+ cli_file = '/tmp/pipeline/mov_008/mov_008.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/mov_008/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/mov_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)
+ self.dut.send_expect("^C", "# ", 20)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_table_001(self):
- # rule 0 test
- in_pcap_file = 'pipeline/xor_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/xor_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 1, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/table_001/table_001.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 0, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/table_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/table_001/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 3, in_pcap_file, out_pcap_file, filters)
+ def test_vxlan_001(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 2, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/vxlan_001/vxlan_001.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap_0 = 'pipeline/vxlan_001/pcap_files/in_1.txt'
+ in_pcap_1 = 'pipeline/vxlan_001/pcap_files/in_2.txt'
+ in_pcap_2 = 'pipeline/vxlan_001/pcap_files/in_3.txt'
+ in_pcap_3 = 'pipeline/vxlan_001/pcap_files/in_4.txt'
+ out_pcap_0 = 'pipeline/vxlan_001/pcap_files/out_1.txt'
+ out_pcap_1 = 'pipeline/vxlan_001/pcap_files/out_2.txt'
+ out_pcap_2 = 'pipeline/vxlan_001/pcap_files/out_3.txt'
+ out_pcap_3 = 'pipeline/vxlan_001/pcap_files/out_4.txt'
+
+ in_pcap = [in_pcap_0, in_pcap_1, in_pcap_2, in_pcap_3]
+ out_pcap = [out_pcap_0, out_pcap_1, out_pcap_2, out_pcap_3]
+ filters = ["udp"] * 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)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ def test_dma_001(self):
- def test_xor_002(self):
+ cli_file = '/tmp/pipeline/dma_001/dma_001.cli'
+ self.run_dpdk_app(cli_file)
- cli_file = '/tmp/pipeline/xor_002/xor_002.cli'
+ in_pcap = ['pipeline/dma_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/dma_001/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)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ def test_dma_002(self):
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ cli_file = '/tmp/pipeline/dma_002/dma_002.cli'
+ self.run_dpdk_app(cli_file)
- # rule 0 test
- in_pcap_file = 'pipeline/xor_002/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/xor_002/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/dma_002/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/dma_002/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)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ def test_dma_003(self):
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/dma_003/dma_003.cli'
+ self.run_dpdk_app(cli_file)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/dma_003/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/dma_003/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)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ def test_dma_004(self):
- def test_xor_003(self):
+ cli_file = '/tmp/pipeline/dma_004/dma_004.cli'
+ self.run_dpdk_app(cli_file)
- cli_file = '/tmp/pipeline/xor_003/xor_003.cli'
+ in_pcap = ['pipeline/dma_004/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/dma_004/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)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ def test_dma_005(self):
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ cli_file = '/tmp/pipeline/dma_005/dma_005.cli'
+ self.run_dpdk_app(cli_file)
- # rule 0 test
- in_pcap_file = 'pipeline/xor_003/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/xor_003/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/dma_005/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/dma_005/pcap_files/out_1.txt'] * 4
+ filters = ["vlan"] * 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)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ def test_dma_006(self):
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/dma_006/dma_006.cli'
+ self.run_dpdk_app(cli_file)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/dma_006/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/dma_006/pcap_files/out_1.txt'] * 4
+ filters = ["udp port 4532"] * 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)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ def test_dma_007(self):
- def test_xor_004(self):
+ cli_file = '/tmp/pipeline/dma_007/dma_007.cli'
+ self.run_dpdk_app(cli_file)
- cli_file = '/tmp/pipeline/xor_004/xor_004.cli'
+ in_pcap = ['pipeline/dma_007/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/dma_007/pcap_files/out_1.txt'] * 4
+ filters = ["udp port 4532"] * 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)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ def test_dma_008(self):
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ cli_file = '/tmp/pipeline/dma_008/dma_008.cli'
+ self.run_dpdk_app(cli_file)
- # rule 0 test
- in_pcap_file = 'pipeline/xor_004/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/xor_004/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/dma_008/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/dma_008/pcap_files/out_1.txt'] * 4
+ filters = ["udp port 4532"] * 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)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ def test_jump_001(self):
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_001/jump_001.cli'
+ self.run_dpdk_app(cli_file)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_001/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)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ def test_jump_002(self):
- def test_xor_005(self):
+ cli_file = '/tmp/pipeline/jump_002/jump_002.cli'
+ self.run_dpdk_app(cli_file)
- cli_file = '/tmp/pipeline/xor_005/xor_005.cli'
+ in_pcap = ['pipeline/jump_002/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_002/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)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ def test_jump_003(self):
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ cli_file = '/tmp/pipeline/jump_003/jump_003.cli'
+ self.run_dpdk_app(cli_file)
- # rule 0 test
- in_pcap_file = 'pipeline/xor_005/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/xor_005/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_003/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_003/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)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ def test_jump_004(self):
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_004/jump_004.cli'
+ self.run_dpdk_app(cli_file)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_004/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_004/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)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ def test_jump_005(self):
- def test_xor_006(self):
- """
- find entry in the table based on the des mac address,
- then update the src mac address to the mac address in the table.
- """
+ cli_file = '/tmp/pipeline/jump_005/jump_005.cli'
+ self.run_dpdk_app(cli_file)
- cli_file = '/tmp/pipeline/xor_006/xor_006.cli'
+ in_pcap = ['pipeline/jump_005/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_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)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ def test_jump_006(self):
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ cli_file = '/tmp/pipeline/jump_006/jump_006.cli'
+ self.run_dpdk_app(cli_file)
- in_pcap_file = 'pipeline/xor_006/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/xor_006/pcap_files/out_1.txt'
- filters = "tcp"
+ in_pcap = ['pipeline/jump_006/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_006/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)
- # rule 0 test
- sniff_pkts = self.send_and_sniff_pkts(0, 1, in_pcap_file, out_pcap_file, filters)
+ def test_jump_007(self):
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_007/jump_007.cli'
+ self.run_dpdk_app(cli_file)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 3, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_007/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_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)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 2, in_pcap_file, out_pcap_file, filters)
+ def test_jump_008(self):
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_008/jump_008.cli'
+ self.run_dpdk_app(cli_file)
- def test_xor_007(self):
- """
- find entry in the table based on the des mac address,
- then update the src mac address to the mac address in the table.
- """
+ in_pcap = ['pipeline/jump_008/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_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)
+ self.dut.send_expect("^C", "# ", 20)
- cli_file = '/tmp/pipeline/xor_007/xor_007.cli'
+ def test_jump_009(self):
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_009/jump_009.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ in_pcap = ['pipeline/jump_009/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_009/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)
- in_pcap_file = 'pipeline/xor_007/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/xor_007/pcap_files/out_1.txt'
- filters = "tcp"
+ def test_jump_010(self):
- # rule 0 test
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_010/jump_010.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_010/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_010/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_jump_011(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_011/jump_011.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/jump_011/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_011/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_xor_008(self):
+ def test_jump_012(self):
- cli_file = '/tmp/pipeline/xor_008/xor_008.cli'
+ cli_file = '/tmp/pipeline/jump_012/jump_012.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/jump_012/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_012/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_jump_013(self):
- # rule 0 test
- in_pcap_file = 'pipeline/xor_008/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/xor_008/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_013/jump_013.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_013/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_013/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_jump_014(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_014/jump_014.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/jump_014/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_014/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_add_001(self):
+ def test_jump_015(self):
- cli_file = '/tmp/pipeline/add_001/add_001.cli'
+ cli_file = '/tmp/pipeline/jump_015/jump_015.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/jump_015/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_015/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_jump_016(self):
- # rule 0 test
- in_pcap_file = 'pipeline/add_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/add_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_016/jump_016.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_016/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_016/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_jump_017(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_017/jump_017.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/jump_017/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_017/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_add_002(self):
+ def test_jump_018(self):
- cli_file = '/tmp/pipeline/add_002/add_002.cli'
+ cli_file = '/tmp/pipeline/jump_018/jump_018.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/jump_018/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_018/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_jump_019(self):
- # rule 0 test
- in_pcap_file = 'pipeline/add_002/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/add_002/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_019/jump_019.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_019/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_019/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_jump_020(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_020/jump_020.cli'
+ self.run_dpdk_app(cli_file)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/jump_020/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_020/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_add_003(self):
+ def test_jump_021(self):
- cli_file = '/tmp/pipeline/add_003/add_003.cli'
+ cli_file = '/tmp/pipeline/jump_021/jump_021.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/jump_021/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_021/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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_jump_022(self):
- # rule 0 test
- in_pcap_file = 'pipeline/add_003/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/add_003/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 1, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_022/jump_022.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 2, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_022/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_022/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 3, in_pcap_file, out_pcap_file, filters)
+ def test_jump_023(self):
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_023/jump_023.cli'
+ self.run_dpdk_app(cli_file)
- def test_add_004(self):
+ in_pcap = ['pipeline/jump_023/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_023/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)
- cli_file = '/tmp/pipeline/add_004/add_004.cli'
+ def test_jump_024(self):
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_024/jump_024.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ in_pcap = ['pipeline/jump_024/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_024/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)
- # rule 0 test
- in_pcap_file = 'pipeline/add_004/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/add_004/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ def test_jump_025(self):
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_025/jump_025.cli'
+ self.run_dpdk_app(cli_file)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_025/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_025/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)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ def test_jump_026(self):
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_026/jump_026.cli'
+ self.run_dpdk_app(cli_file)
- def test_add_005(self):
+ in_pcap = ['pipeline/jump_026/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_026/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)
- cli_file = '/tmp/pipeline/add_005/add_005.cli'
+ def test_jump_027(self):
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_027/jump_027.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ in_pcap = ['pipeline/jump_027/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_027/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)
- # rule 0 test
- in_pcap_file = 'pipeline/add_005/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/add_005/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ def test_jump_028(self):
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_028/jump_028.cli'
+ self.run_dpdk_app(cli_file)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_028/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_028/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)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ def test_jump_029(self):
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_029/jump_029.cli'
+ self.run_dpdk_app(cli_file)
- def test_add_006(self):
+ in_pcap = ['pipeline/jump_029/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_029/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)
- cli_file = '/tmp/pipeline/add_006/add_006.cli'
+ def test_jump_030(self):
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_030/jump_030.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ in_pcap = ['pipeline/jump_030/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_030/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)
- # rule 0 test
- in_pcap_file = 'pipeline/add_006/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/add_006/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ def test_jump_031(self):
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_031/jump_031.cli'
+ self.run_dpdk_app(cli_file)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_031/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_031/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)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ def test_jump_032(self):
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_032/jump_032.cli'
+ self.run_dpdk_app(cli_file)
- def test_add_007(self):
+ in_pcap = ['pipeline/jump_032/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_032/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)
- cli_file = '/tmp/pipeline/add_007/add_007.cli'
+ def test_jump_033(self):
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_033/jump_033.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ in_pcap = ['pipeline/jump_033/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_033/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)
- # rule 0 test
- in_pcap_file = 'pipeline/add_007/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/add_007/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ def test_jump_034(self):
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_034/jump_034.cli'
+ self.run_dpdk_app(cli_file)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_034/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_034/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)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ def test_jump_035(self):
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_035/jump_035.cli'
+ self.run_dpdk_app(cli_file)
- def test_add_008(self):
+ in_pcap = ['pipeline/jump_035/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_035/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)
- cli_file = '/tmp/pipeline/add_008/add_008.cli'
+ def test_jump_036(self):
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_036/jump_036.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ in_pcap = ['pipeline/jump_036/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_036/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)
- # rule 0 test
- in_pcap_file = 'pipeline/add_008/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/add_008/pcap_files/out_1.txt'
- filters = "udp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ def test_jump_037(self):
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_037/jump_037.cli'
+ self.run_dpdk_app(cli_file)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_037/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_037/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)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ def test_jump_038(self):
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_038/jump_038.cli'
+ self.run_dpdk_app(cli_file)
- def test_shl_001(self):
+ in_pcap = ['pipeline/jump_038/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_038/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)
- cli_file = '/tmp/pipeline/shl_001/shl_001.cli'
+ def test_jump_039(self):
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_039/jump_039.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ in_pcap = ['pipeline/jump_039/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_039/pcap_files/out_1.txt'] * 4
+ filters = [""] * 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)
- # rule 0 test
- in_pcap_file = 'pipeline/shl_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/shl_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ def test_jump_040(self):
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_040/jump_040.cli'
+ self.run_dpdk_app(cli_file)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_040/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_040/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)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ def test_jump_041(self):
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_041/jump_041.cli'
+ self.run_dpdk_app(cli_file)
- def test_shl_002(self):
+ in_pcap = ['pipeline/jump_041/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_041/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)
- cli_file = '/tmp/pipeline/shl_002/shl_002.cli'
+ def test_jump_042(self):
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_042/jump_042.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ in_pcap = ['pipeline/jump_042/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_042/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)
- # rule 0 test
- in_pcap_file = 'pipeline/shl_002/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/shl_002/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ def test_jump_043(self):
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_043/jump_043.cli'
+ self.run_dpdk_app(cli_file)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_043/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_043/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)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ def test_jump_044(self):
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_044/jump_044.cli'
+ self.run_dpdk_app(cli_file)
- def test_shl_003(self):
+ in_pcap = ['pipeline/jump_044/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_044/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)
- cli_file = '/tmp/pipeline/shl_003/shl_003.cli'
+ def test_jump_045(self):
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_045/jump_045.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ in_pcap = ['pipeline/jump_045/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_045/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)
- # rule 0 test
- in_pcap_file = 'pipeline/shl_003/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/shl_003/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ def test_jump_046(self):
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_046/jump_046.cli'
+ self.run_dpdk_app(cli_file)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_046/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_046/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)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ def test_jump_047(self):
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_047/jump_047.cli'
+ self.run_dpdk_app(cli_file)
- def test_shl_004(self):
+ in_pcap = ['pipeline/jump_047/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_047/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)
- cli_file = '/tmp/pipeline/shl_004/shl_004.cli'
+ def test_jump_048(self):
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_048/jump_048.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ in_pcap = ['pipeline/jump_048/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_048/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)
- # rule 0 test
- in_pcap_file = 'pipeline/shl_004/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/shl_004/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ def test_jump_049(self):
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_049/jump_049.cli'
+ self.run_dpdk_app(cli_file)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_049/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_049/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)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ def test_jump_050(self):
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_050/jump_050.cli'
+ self.run_dpdk_app(cli_file)
- def test_shl_005(self):
+ in_pcap = ['pipeline/jump_050/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_050/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)
- cli_file = '/tmp/pipeline/shl_005/shl_005.cli'
+ def test_jump_051(self):
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_051/jump_051.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ in_pcap = ['pipeline/jump_051/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_051/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)
- # rule 0 test
- in_pcap_file = 'pipeline/shl_005/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/shl_005/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ def test_jump_052(self):
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_052/jump_052.cli'
+ self.run_dpdk_app(cli_file)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_052/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_052/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)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ def test_jump_053(self):
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_053/jump_053.cli'
+ self.run_dpdk_app(cli_file)
- def test_shl_006(self):
+ in_pcap = ['pipeline/jump_053/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_053/pcap_files/out_1.txt'] * 4
+ filters = [""] * 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)
- cli_file = '/tmp/pipeline/shl_006/shl_006.cli'
+ def test_jump_054(self):
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/jump_054/jump_054.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ in_pcap = ['pipeline/jump_054/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_054/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)
- # rule 0 test
- in_pcap_file = 'pipeline/shl_006/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/shl_006/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ def test_jump_055(self):
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/jump_055/jump_055.cli'
+ self.run_dpdk_app(cli_file)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/jump_055/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/jump_055/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)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ def test_ckadd_001(self):
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/ckadd_001/ckadd_001.cli'
+ self.run_dpdk_app(cli_file)
- def test_shl_007(self):
+ in_pcap = ['pipeline/ckadd_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/ckadd_001/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)
- cli_file = '/tmp/pipeline/shl_007/shl_007.cli'
+ def test_ckadd_009(self):
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/ckadd_009/ckadd_009.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ in_pcap = ['pipeline/ckadd_009/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/ckadd_009/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)
- # rule 0 test
- in_pcap_file = 'pipeline/shl_007/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/shl_007/pcap_files/out_1.txt'
- filters = "udp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ def test_ckadd_010(self):
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/ckadd_010/ckadd_010.cli'
+ self.run_dpdk_app(cli_file)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/ckadd_010/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/ckadd_010/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)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ def test_cksub_001(self):
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/cksub_001/cksub_001.cli'
+ self.run_dpdk_app(cli_file)
- def test_shl_008(self):
+ in_pcap = ['pipeline/cksub_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/cksub_001/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)
- cli_file = '/tmp/pipeline/shl_008/shl_008.cli'
+ def test_invalidate_001(self):
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ cli_file = '/tmp/pipeline/invalidate_001/invalidate_001.cli'
+ self.run_dpdk_app(cli_file)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ in_pcap = ['pipeline/invalidate_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/invalidate_001/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)
- # rule 0 test
- in_pcap_file = 'pipeline/shl_008/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/shl_008/pcap_files/out_1.txt'
- filters = "udp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ def test_validate_001(self):
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/validate_001/validate_001.cli'
+ self.run_dpdk_app(cli_file)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/validate_001/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/validate_001/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)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ def test_table_002(self):
+ cli_file = '/tmp/pipeline/table_002/table_002.cli'
+ self.run_dpdk_app(cli_file)
sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ s = self.connect_cli_server()
- def test_shr_001(self):
+ # empty table scenario
+ in_pcap = ['pipeline/table_002/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/table_002/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_file = '/tmp/pipeline/shr_001/shr_001.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/shr_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/shr_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ # single rule scenario
+ CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_2.txt'
+ CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
- def test_shr_002(self):
+ in_pcap = ['pipeline/table_002/pcap_files/in_2.txt'] * 4
+ out_pcap = ['pipeline/table_002/pcap_files/out_2.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_file = '/tmp/pipeline/shr_002/shr_002.cli'
+ # two rules scenario
+ CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_3.txt'
+ CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/table_002/pcap_files/in_3.txt'] * 4
+ out_pcap = ['pipeline/table_002/pcap_files/out_3.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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ # delete one rule scenario
+ CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_4_1.txt'
+ CLI_CMD = 'pipeline PIPELINE0 table table_002_table update none {} none\n'.format(CMD_FILE)
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
- # rule 0 test
- in_pcap_file = 'pipeline/shr_002/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/shr_002/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/table_002/pcap_files/in_4_1.txt'] * 4
+ out_pcap = ['pipeline/table_002/pcap_files/out_4_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)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ # delete all rules scenario
+ CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_4_2.txt'
+ CLI_CMD = 'pipeline PIPELINE0 table table_002_table update none {} none\n'.format(CMD_FILE)
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/table_002/pcap_files/in_4_2.txt'] * 4
+ out_pcap = ['pipeline/table_002/pcap_files/out_4_2.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)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ # action update scenario (restore one of the previously deleted rules and check the update)
+ CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_5_1.txt'
+ CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = 'pipeline/table_002/pcap_files/in_5_1.txt'
+ out_pcap = 'pipeline/table_002/pcap_files/out_5_1.txt'
+ self.send_and_sniff_pkts(0, 0, in_pcap, out_pcap, "tcp")
- def test_shr_003(self):
+ # action update scenario (change the action of restored rule and check the update)
+ CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_5_2.txt'
+ CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
- cli_file = '/tmp/pipeline/shr_003/shr_003.cli'
+ in_pcap = ['pipeline/table_002/pcap_files/in_5_1.txt'] * 4
+ out_pcap = ['pipeline/table_002/pcap_files/out_5_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)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ # deafult action scenario [empty table]
+ CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_6_1.txt' # delete the previously added rule
+ CLI_CMD = 'pipeline PIPELINE0 table table_002_table update none {} none\n'.format(CMD_FILE)
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ in_pcap = ['pipeline/table_002/pcap_files/in_6_1.txt'] * 4
+ out_pcap = ['pipeline/table_002/pcap_files/out_6_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)
- # rule 0 test
- in_pcap_file = 'pipeline/shr_003/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/shr_003/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ # deafult action scenario [table with one rule]
+ '''
+ Add key A => Lookup HIT for the right packet with the specific key associated action executed
+ Lookup MISS for any other packets with default action executed
+ '''
+ CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_6_2.txt' # add a new rule
+ CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/table_002/pcap_files/in_6_2.txt'] * 4
+ out_pcap = ['pipeline/table_002/pcap_files/out_6_2.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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ def test_table_003(self):
+ cli_file = '/tmp/pipeline/table_003/table_003.cli'
+ self.run_dpdk_app(cli_file)
sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_shr_004(self):
-
- cli_file = '/tmp/pipeline/shr_004/shr_004.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/shr_004/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/shr_004/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ s = self.connect_cli_server()
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ # Empty table scenario
+ in_pcap = ['pipeline/table_003/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/table_003/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)
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ # Single rule scenario
+ CMD_FILE = '/tmp/pipeline/table_003/cmd_files/cmd_2.txt'
+ CLI_CMD = 'pipeline PIPELINE0 table table_003_table update {} none none\n'.format(CMD_FILE)
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
- def test_shr_005(self):
+ in_pcap = ['pipeline/table_003/pcap_files/in_2.txt'] * 4
+ out_pcap = ['pipeline/table_003/pcap_files/out_2.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_file = '/tmp/pipeline/shr_005/shr_005.cli'
+ # test two rules scenario
+ CMD_FILE = '/tmp/pipeline/table_003/cmd_files/cmd_3.txt'
+ CLI_CMD = 'pipeline PIPELINE0 table table_003_table update {} none none\n'.format(CMD_FILE)
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = ['pipeline/table_003/pcap_files/in_3.txt'] * 4
+ out_pcap = ['pipeline/table_003/pcap_files/out_3.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)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ # delete one rule scenario
+ CMD_FILE = '/tmp/pipeline/table_003/cmd_files/cmd_4_1.txt'
+ CLI_CMD = 'pipeline PIPELINE0 table table_003_table update none {} none\n'.format(CMD_FILE)
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
- # rule 0 test
- in_pcap_file = 'pipeline/shr_005/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/shr_005/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/table_003/pcap_files/in_4_1.txt'] * 4
+ out_pcap = ['pipeline/table_003/pcap_files/out_4_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)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ # delete all rules scenario
+ CMD_FILE = '/tmp/pipeline/table_003/cmd_files/cmd_4_2.txt'
+ CLI_CMD = 'pipeline PIPELINE0 table table_003_table update none {} none\n'.format(CMD_FILE)
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/table_003/pcap_files/in_4_2.txt'] * 4
+ out_pcap = ['pipeline/table_003/pcap_files/out_4_2.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)
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ # action update scenario (restore one of the previously deleted rules and check the update)
+ CMD_FILE = '/tmp/pipeline/table_003/cmd_files/cmd_5_1.txt'
+ CLI_CMD = 'pipeline PIPELINE0 table table_003_table update {} none none\n'.format(CMD_FILE)
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ in_pcap = 'pipeline/table_003/pcap_files/in_5_1.txt'
+ out_pcap = 'pipeline/table_003/pcap_files/out_5_1.txt'
+ self.send_and_sniff_pkts(0, 0, in_pcap, out_pcap, "tcp")
- def test_shr_006(self):
+ # action update scenario (change the action of restored rule and check the update)
+ CMD_FILE = '/tmp/pipeline/table_003/cmd_files/cmd_5_2.txt'
+ CLI_CMD = 'pipeline PIPELINE0 table table_003_table update {} none none\n'.format(CMD_FILE)
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ in_pcap = ['pipeline/table_003/pcap_files/in_5_1.txt'] * 4
+ out_pcap = ['pipeline/table_003/pcap_files/out_5_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)
+
+ # Default action scenario [Empty table]
+ CMD_FILE = '/tmp/pipeline/table_003/cmd_files/cmd_6_1_1.txt' # delete the previously added rule
+ CMD_FILE_2 = '/tmp/pipeline/table_003/cmd_files/cmd_6_1_2.txt' # change the default action of table
+ CLI_CMD = 'pipeline PIPELINE0 table table_003_table update none {} {} \n'.format(CMD_FILE, CMD_FILE_2)
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ in_pcap = ['pipeline/table_003/pcap_files/in_6_1.txt'] * 4
+ out_pcap = ['pipeline/table_003/pcap_files/out_6_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)
+
+ # Default action scenario [Table with one rule]
+ '''
+ Add key A => Lookup HIT for the right packet with the specific key associated action executed
+ Lookup MISS for any other packets with default action executed
+ '''
+ CMD_FILE = '/tmp/pipeline/table_003/cmd_files/cmd_6_2.txt' # add a new rule
+ CLI_CMD = 'pipeline PIPELINE0 table table_003_table update {} none none\n'.format(CMD_FILE)
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
- cli_file = '/tmp/pipeline/shr_006/shr_006.cli'
+ in_pcap = ['pipeline/table_003/pcap_files/in_6_2.txt'] * 4
+ out_pcap = ['pipeline/table_003/pcap_files/out_6_2.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)
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ def test_table_004(self):
- # rule 0 test
- in_pcap_file = 'pipeline/shr_006/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/shr_006/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/table_004/table_004.cli'
+ self.run_dpdk_app(cli_file)
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ in_pcap = ['pipeline/table_004/pcap_files/in_1.txt'] * 4
+ out_pcap = ['pipeline/table_004/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)
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ def test_reg_001(self):
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ cli_file = '/tmp/pipeline/reg_001/reg_001.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ # Read default initial value
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x0\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
- def test_shr_007(self):
+ # Update the register array location
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x0 0xab\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
- cli_file = '/tmp/pipeline/shr_007/shr_007.cli'
+ # Verify updated value
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x0\n'
+ self.socket_send_cmd(s, CLI_CMD, "0xab\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_002(self):
+
+ cli_file = '/tmp/pipeline/reg_002/reg_002.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Update the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0x123456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0x12345678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0x1234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0x12\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ s.close()
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ # Read updated values through packet
+ in_pcap_file = 'pipeline/reg_002/pcap_files/in_1.txt'
+ out_pcap_file = 'pipeline/reg_002/pcap_files/out_1.txt'
+ self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, "tcp")
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_003(self):
+
+ cli_file = '/tmp/pipeline/reg_003/reg_003.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Update the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0x123456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0x12345678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0x1234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0x12\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ s.close()
- # rule 0 test
- in_pcap_file = 'pipeline/shr_007/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/shr_007/pcap_files/out_1.txt'
- filters = "udp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ # Read updated values through packet
+ in_pcap_file = 'pipeline/reg_003/pcap_files/in_1.txt'
+ out_pcap_file = 'pipeline/reg_003/pcap_files/out_1.txt'
+ self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, "tcp")
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_004(self):
+
+ cli_file = '/tmp/pipeline/reg_004/reg_004.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Update the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0x123456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0x12345678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0x1234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0x12\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ s.close()
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ # Read updated values through packet
+ in_pcap_file = 'pipeline/reg_004/pcap_files/in_1.txt'
+ out_pcap_file = 'pipeline/reg_004/pcap_files/out_1.txt'
+ self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, "tcp")
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_005(self):
+
+ cli_file = '/tmp/pipeline/reg_005/reg_005.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Update the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0x123456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0x12345678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0x1234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0x12\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ s.close()
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ # Read updated values through packet
+ in_pcap_file = 'pipeline/reg_005/pcap_files/in_1.txt'
+ out_pcap_file = 'pipeline/reg_005/pcap_files/out_1.txt'
+ self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, "tcp")
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_006(self):
+
+ cli_file = '/tmp/pipeline/reg_006/reg_006.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Update the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0x123456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0x12345678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0x1234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0x12\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send a packet to trigger the execution of apply block
+ in_pcap_file = 'pipeline/reg_006/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify written vs read values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa3a4\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb3b4\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_007(self):
+
+ cli_file = '/tmp/pipeline/reg_007/reg_007.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Update the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0x123456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0x12345678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0x1234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0x12\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send a packet to trigger the execution of apply block
+ in_pcap_file = 'pipeline/reg_007/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify written vs read values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa3a4\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb3b4\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_008(self):
+
+ cli_file = '/tmp/pipeline/reg_008/reg_008.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Update the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0x123456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0x12345678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0x1234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0x12\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send a packet to trigger the execution of apply block
+ in_pcap_file = 'pipeline/reg_008/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify written vs read values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa3a4\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb3b4\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
- def test_shr_008(self):
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_009(self):
+
+ cli_file = '/tmp/pipeline/reg_009/reg_009.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Update the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0x123456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0x12345678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0x1234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0x12\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send a packet to trigger the execution of apply block
+ in_pcap_file = 'pipeline/reg_009/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify written vs read values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa3a4\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb3b4\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
- cli_file = '/tmp/pipeline/shr_008/shr_008.cli'
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_010(self):
+
+ cli_file = '/tmp/pipeline/reg_010/reg_010.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Verify the default initial values of zero
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_010/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x6\npipeline> ")
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_011(self):
+
+ cli_file = '/tmp/pipeline/reg_011/reg_011.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Verify the default initial values of zero
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_011/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x6\npipeline> ")
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_012(self):
+
+ cli_file = '/tmp/pipeline/reg_012/reg_012.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Verify the default initial values of zero
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_012/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
- # rule 0 test
- in_pcap_file = 'pipeline/shr_008/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/shr_008/pcap_files/out_1.txt'
- filters = "udp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_013(self):
+
+ cli_file = '/tmp/pipeline/reg_013/reg_013.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Verify the default initial values of zero
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x06\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_013/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x6\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x06\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x9876543210987654\npipeline> ")
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_014(self):
+
+ cli_file = '/tmp/pipeline/reg_014/reg_014.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Verify the default initial values of zero
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_014/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x6\npipeline> ")
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_015(self):
+
+ cli_file = '/tmp/pipeline/reg_015/reg_015.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Verify the default initial values of zero
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_015/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x6\npipeline> ")
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_016(self):
+
+ cli_file = '/tmp/pipeline/reg_016/reg_016.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Verify the default initial values of zero
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_016/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_017(self):
+
+ cli_file = '/tmp/pipeline/reg_017/reg_017.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Verify the default initial values of zero
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_017/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
- def test_sub_001(self):
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_018(self):
+
+ cli_file = '/tmp/pipeline/reg_018/reg_018.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Verify the default initial values of zero
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_018/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
- cli_file = '/tmp/pipeline/sub_001/sub_001.cli'
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_019(self):
+
+ cli_file = '/tmp/pipeline/reg_019/reg_019.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Verify the default initial values of zero
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_019/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_020(self):
+
+ cli_file = '/tmp/pipeline/reg_020/reg_020.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Verify the default initial values of zero
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_020/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_021(self):
+
+ cli_file = '/tmp/pipeline/reg_021/reg_021.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Verify the default initial values of zero
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_021/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
- # rule 0 test
- in_pcap_file = 'pipeline/sub_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/sub_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_022(self):
+
+ cli_file = '/tmp/pipeline/reg_022/reg_022.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Verify the default initial values of zero
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_022/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x6\npipeline> ")
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_023(self):
+
+ cli_file = '/tmp/pipeline/reg_023/reg_023.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Verify the default initial values of zero
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_023/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_024(self):
+
+ cli_file = '/tmp/pipeline/reg_024/reg_024.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Verify the default initial values of zero
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_024/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_025(self):
+
+ cli_file = '/tmp/pipeline/reg_025/reg_025.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Verify the default initial values of zero
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_025/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_026(self):
+
+ cli_file = '/tmp/pipeline/reg_026/reg_026.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_026/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
- def test_sub_002(self):
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_027(self):
+
+ cli_file = '/tmp/pipeline/reg_027/reg_027.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_027/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
- cli_file = '/tmp/pipeline/sub_002/sub_002.cli'
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_028(self):
+
+ cli_file = '/tmp/pipeline/reg_028/reg_028.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_028/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_029(self):
+
+ cli_file = '/tmp/pipeline/reg_029/reg_029.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_029/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_030(self):
+
+ cli_file = '/tmp/pipeline/reg_030/reg_030.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_030/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
- # rule 0 test
- in_pcap_file = 'pipeline/sub_002/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/sub_002/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_031(self):
+
+ cli_file = '/tmp/pipeline/reg_031/reg_031.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_031/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_032(self):
+
+ cli_file = '/tmp/pipeline/reg_032/reg_032.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_032/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_033(self):
+
+ cli_file = '/tmp/pipeline/reg_033/reg_033.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_033/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_034(self):
+
+ cli_file = '/tmp/pipeline/reg_034/reg_034.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_034/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_035(self):
+
+ cli_file = '/tmp/pipeline/reg_035/reg_035.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_035/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
- def test_sub_003(self):
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_036(self):
+
+ cli_file = '/tmp/pipeline/reg_036/reg_036.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_036/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
- cli_file = '/tmp/pipeline/sub_003/sub_003.cli'
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_037(self):
+
+ cli_file = '/tmp/pipeline/reg_037/reg_037.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_037/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_038(self):
+
+ cli_file = '/tmp/pipeline/reg_038/reg_038.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_038/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_039(self):
+
+ cli_file = '/tmp/pipeline/reg_039/reg_039.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_039/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
- # rule 0 test
- in_pcap_file = 'pipeline/sub_003/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/sub_003/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_040(self):
+
+ cli_file = '/tmp/pipeline/reg_040/reg_040.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_040/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_041(self):
+
+ cli_file = '/tmp/pipeline/reg_041/reg_041.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_041/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Update the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_042(self):
+
+ cli_file = '/tmp/pipeline/reg_042/reg_042.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_042/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_043(self):
+
+ cli_file = '/tmp/pipeline/reg_043/reg_043.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_043/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_044(self):
+
+ cli_file = '/tmp/pipeline/reg_044/reg_044.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_044/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+ self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
- def test_sub_004(self):
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_reg_045(self):
+
+ cli_file = '/tmp/pipeline/reg_045/reg_045.cli'
+ self.run_dpdk_app(cli_file)
+ sleep(CLI_SERVER_CONNECT_DELAY)
+ s = self.connect_cli_server()
+
+ # Initialize the register array locations with required values
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ # Send packet to DUT to update the register array
+ in_pcap_file = 'pipeline/reg_045/pcap_files/in_1.txt'
+ self.send_pkts(0, 0, in_pcap_file)
+
+ # Verify whether the register array is updated with required values
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+ self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
- cli_file = '/tmp/pipeline/sub_004/sub_004.cli'
+ s.close()
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_met_001(self):
+
+ cli_file = '/tmp/pipeline/met_001/met_001.cli'
+ self.run_dpdk_app(cli_file)
+
+ # Platinum Profile with High Packet Transmission Rate
+ in_pcap = ['pipeline/met_001/pcap_files/in_1.txt']
+ out_pcap_1 = 'pipeline/met_001/pcap_files/out_11.txt'
+ out_pcap_2 = 'pipeline/met_001/pcap_files/out_12.txt'
+ out_pcap_3 = 'pipeline/met_001/pcap_files/out_13.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ filters = ["tcp"] * 3
+ tx_port = [0]
+ rx_port = [0, 1, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+ # Platinum Profile with Low Packet Transmission Rate
+ out_pcap_1 = 'pipeline/met_001/pcap_files/out_21.txt'
+ out_pcap_2 = 'pipeline/met_001/pcap_files/out_22.txt'
+ out_pcap_3 = 'pipeline/met_001/pcap_files/out_23.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+
+ # Gold Profile with High Packet Transmission Rate
+ s = self.connect_cli_server()
+ CLI_CMD = 'pipeline PIPELINE0 meter profile gold add cir 460 pir 1380 cbs 100 pbs 150\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 meter MET_ARRAY_1 from 0 to 0 set profile gold\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ CLI_CMD = 'pipeline PIPELINE0 meter profile platinum delete\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+ out_pcap_1 = 'pipeline/met_001/pcap_files/out_31.txt'
+ out_pcap_2 = 'pipeline/met_001/pcap_files/out_32.txt'
+ out_pcap_3 = 'pipeline/met_001/pcap_files/out_33.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ tx_port = [0]
+ rx_port = [0, 1, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+ # Default Profile with High Packet Transmission Rate
+ CLI_CMD = 'pipeline PIPELINE0 meter MET_ARRAY_1 from 0 to 0 reset\n'
+ self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+ s.close()
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/sub_004/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/sub_004/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_sub_005(self):
-
- cli_file = '/tmp/pipeline/sub_005/sub_005.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/sub_005/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/sub_005/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_sub_006(self):
-
- cli_file = '/tmp/pipeline/sub_006/sub_006.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/sub_006/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/sub_006/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_sub_007(self):
-
- cli_file = '/tmp/pipeline/sub_007/sub_007.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/sub_007/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/sub_007/pcap_files/out_1.txt'
- filters = "udp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_sub_008(self):
-
- cli_file = '/tmp/pipeline/sub_008/sub_008.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/sub_008/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/sub_008/pcap_files/out_1.txt'
- filters = "udp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_mov_001(self):
-
- cli_file = '/tmp/pipeline/mov_001/mov_001.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/mov_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/mov_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_mov_002(self):
- """
- mov_002: swap destination and source MAC address of packets received on port
- """
- cli_file = '/tmp/pipeline/mov_002/mov_002.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/mov_002/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/mov_002/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_mov_003(self):
-
- cli_file = '/tmp/pipeline/mov_003/mov_003.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/mov_003/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/mov_003/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_mov_004(self):
- """
- find entry in the table based on the des mac address,
- then update the src mac address to the mac address in the table.
- """
-
- cli_file = '/tmp/pipeline/mov_004/mov_004.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- in_pcap_file = 'pipeline/mov_004/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/mov_004/pcap_files/out_1.txt'
- filters = "tcp"
-
- # rule 0 test
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_mov_005(self):
- """
- find entry in the table based on the des mac address,
- then update the src mac address to the mac address in the table.
- """
-
- cli_file = '/tmp/pipeline/mov_005/mov_005.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- in_pcap_file = 'pipeline/mov_005/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/mov_005/pcap_files/out_1.txt'
- filters = "tcp"
-
- # rule 0 test
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 0, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_mov_007(self):
- """
- find entry in the table based on the des mac address,
- then update the src mac address to the mac address in the table.
- """
-
- cli_file = '/tmp/pipeline/mov_007/mov_007.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- in_pcap_file = 'pipeline/mov_007/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/mov_007/pcap_files/out_1.txt'
- filters = "tcp"
-
- # rule 0 test
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 0, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_mov_008(self):
- """
- find entry in the table based on the des mac address,
- then update the src mac address to the mac address in the table.
- """
-
- cli_file = '/tmp/pipeline/mov_008/mov_008.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- in_pcap_file = 'pipeline/mov_008/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/mov_008/pcap_files/out_1.txt'
- filters = "tcp"
-
- # rule 0 test
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_table_001(self):
-
- cli_file = '/tmp/pipeline/table_001/table_001.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/table_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/table_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_vxlan_001(self):
- """
- example application: vxlan pipeline
- """
- cli_file = '/tmp/pipeline/vxlan_001/vxlan_001.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/vxlan_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/vxlan_001/pcap_files/out_1.txt'
- filters = "udp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- in_pcap_file = 'pipeline/vxlan_001/pcap_files/in_2.txt'
- out_pcap_file = 'pipeline/vxlan_001/pcap_files/out_2.txt'
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- in_pcap_file = 'pipeline/vxlan_001/pcap_files/in_3.txt'
- out_pcap_file = 'pipeline/vxlan_001/pcap_files/out_3.txt'
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- in_pcap_file = 'pipeline/vxlan_001/pcap_files/in_4.txt'
- out_pcap_file = 'pipeline/vxlan_001/pcap_files/out_4.txt'
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_dma_001(self):
- """
- example application: vxlan pipeline
- """
- cli_file = '/tmp/pipeline/dma_001/dma_001.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/dma_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/dma_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
-
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_dma_002(self):
-
- cli_file = '/tmp/pipeline/dma_002/dma_002.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/dma_002/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/dma_002/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_dma_003(self):
-
- cli_file = '/tmp/pipeline/dma_003/dma_003.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/dma_003/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/dma_003/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_dma_004(self):
-
- cli_file = '/tmp/pipeline/dma_004/dma_004.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/dma_004/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/dma_004/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_dma_005(self):
-
- cli_file = '/tmp/pipeline/dma_005/dma_005.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/dma_005/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/dma_005/pcap_files/out_1.txt'
- filters = "vlan"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_dma_006(self):
-
- cli_file = '/tmp/pipeline/dma_006/dma_006.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/dma_006/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/dma_006/pcap_files/out_1.txt'
- filters = "udp port 4532"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_dma_007(self):
-
- cli_file = '/tmp/pipeline/dma_007/dma_007.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/dma_007/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/dma_007/pcap_files/out_1.txt'
- filters = "udp port 4532"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_dma_008(self):
-
- cli_file = '/tmp/pipeline/dma_008/dma_008.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/dma_008/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/dma_008/pcap_files/out_1.txt'
- filters = "udp port 4532"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_001(self):
-
- cli_file = '/tmp/pipeline/jump_001/jump_001.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_002(self):
-
- cli_file = '/tmp/pipeline/jump_002/jump_002.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_002/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_002/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_003(self):
-
- cli_file = '/tmp/pipeline/jump_003/jump_003.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_003/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_003/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_004(self):
-
- cli_file = '/tmp/pipeline/jump_004/jump_004.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_004/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_004/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_005(self):
-
- cli_file = '/tmp/pipeline/jump_005/jump_005.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_005/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_005/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_006(self):
-
- cli_file = '/tmp/pipeline/jump_006/jump_006.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_006/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_006/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_007(self):
-
- cli_file = '/tmp/pipeline/jump_007/jump_007.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_007/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_007/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_008(self):
-
- cli_file = '/tmp/pipeline/jump_008/jump_008.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_008/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_008/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_009(self):
-
- cli_file = '/tmp/pipeline/jump_009/jump_009.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_009/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_009/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_010(self):
-
- cli_file = '/tmp/pipeline/jump_010/jump_010.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_010/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_010/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_011(self):
-
- cli_file = '/tmp/pipeline/jump_011/jump_011.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_011/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_011/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_012(self):
-
- cli_file = '/tmp/pipeline/jump_012/jump_012.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_012/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_012/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_013(self):
-
- cli_file = '/tmp/pipeline/jump_013/jump_013.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_013/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_013/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_014(self):
-
- cli_file = '/tmp/pipeline/jump_014/jump_014.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_014/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_014/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_015(self):
-
- cli_file = '/tmp/pipeline/jump_015/jump_015.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_015/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_015/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_016(self):
-
- cli_file = '/tmp/pipeline/jump_016/jump_016.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_016/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_016/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_017(self):
-
- cli_file = '/tmp/pipeline/jump_017/jump_017.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_017/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_017/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_018(self):
-
- cli_file = '/tmp/pipeline/jump_018/jump_018.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_018/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_018/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_019(self):
-
- cli_file = '/tmp/pipeline/jump_019/jump_019.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_019/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_019/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_020(self):
-
- cli_file = '/tmp/pipeline/jump_020/jump_020.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_020/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_020/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_021(self):
-
- cli_file = '/tmp/pipeline/jump_021/jump_021.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_021/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_021/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_022(self):
-
- cli_file = '/tmp/pipeline/jump_022/jump_022.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_022/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_022/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_023(self):
-
- cli_file = '/tmp/pipeline/jump_023/jump_023.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_023/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_023/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_024(self):
-
- cli_file = '/tmp/pipeline/jump_024/jump_024.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_024/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_024/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_025(self):
-
- cli_file = '/tmp/pipeline/jump_025/jump_025.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_025/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_025/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_026(self):
-
- cli_file = '/tmp/pipeline/jump_026/jump_026.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_026/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_026/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_027(self):
-
- cli_file = '/tmp/pipeline/jump_027/jump_027.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_027/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_027/pcap_files/out_1.txt'
- filters = ""
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_028(self):
-
- cli_file = '/tmp/pipeline/jump_028/jump_028.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_028/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_028/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_029(self):
-
- cli_file = '/tmp/pipeline/jump_029/jump_029.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_029/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_029/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_030(self):
-
- cli_file = '/tmp/pipeline/jump_030/jump_030.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_030/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_030/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_031(self):
-
- cli_file = '/tmp/pipeline/jump_031/jump_031.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_031/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_031/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_032(self):
-
- cli_file = '/tmp/pipeline/jump_032/jump_032.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_032/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_032/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_033(self):
-
- cli_file = '/tmp/pipeline/jump_033/jump_033.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_033/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_033/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_034(self):
-
- cli_file = '/tmp/pipeline/jump_034/jump_034.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_034/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_034/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_035(self):
-
- cli_file = '/tmp/pipeline/jump_035/jump_035.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_035/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_035/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_036(self):
-
- cli_file = '/tmp/pipeline/jump_036/jump_036.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_036/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_036/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_037(self):
-
- cli_file = '/tmp/pipeline/jump_037/jump_037.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_037/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_037/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_038(self):
-
- cli_file = '/tmp/pipeline/jump_038/jump_038.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_038/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_038/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_039(self):
-
- cli_file = '/tmp/pipeline/jump_039/jump_039.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_039/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_039/pcap_files/out_1.txt'
- filters = ""
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_040(self):
-
- cli_file = '/tmp/pipeline/jump_040/jump_040.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_040/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_040/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_041(self):
-
- cli_file = '/tmp/pipeline/jump_041/jump_041.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_041/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_041/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_042(self):
-
- cli_file = '/tmp/pipeline/jump_042/jump_042.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_042/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_042/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_043(self):
-
- cli_file = '/tmp/pipeline/jump_043/jump_043.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_043/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_043/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_044(self):
-
- cli_file = '/tmp/pipeline/jump_044/jump_044.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_044/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_044/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_045(self):
-
- cli_file = '/tmp/pipeline/jump_045/jump_045.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_045/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_045/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_046(self):
-
- cli_file = '/tmp/pipeline/jump_046/jump_046.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_046/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_046/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_047(self):
-
- cli_file = '/tmp/pipeline/jump_047/jump_047.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_047/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_047/pcap_files/out_1.txt'
- filters = ""
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_048(self):
-
- cli_file = '/tmp/pipeline/jump_048/jump_048.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_048/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_048/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_049(self):
-
- cli_file = '/tmp/pipeline/jump_049/jump_049.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_049/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_049/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_050(self):
-
- cli_file = '/tmp/pipeline/jump_050/jump_050.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_050/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_050/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_051(self):
-
- cli_file = '/tmp/pipeline/jump_051/jump_051.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_051/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_051/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_052(self):
-
- cli_file = '/tmp/pipeline/jump_052/jump_052.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_052/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_052/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_053(self):
-
- cli_file = '/tmp/pipeline/jump_053/jump_053.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_053/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_053/pcap_files/out_1.txt'
- filters = ""
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_054(self):
-
- cli_file = '/tmp/pipeline/jump_054/jump_054.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_054/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_054/pcap_files/out_1.txt'
- filters = ""
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_jump_055(self):
-
- cli_file = '/tmp/pipeline/jump_055/jump_055.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/jump_055/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/jump_055/pcap_files/out_1.txt'
- filters = ""
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_ckadd_001(self):
-
- cli_file = '/tmp/pipeline/ckadd_001/ckadd_001.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/ckadd_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/ckadd_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_ckadd_009(self):
-
- cli_file = '/tmp/pipeline/ckadd_009/ckadd_009.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/ckadd_009/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/ckadd_009/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_ckadd_010(self):
-
- cli_file = '/tmp/pipeline/ckadd_010/ckadd_010.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/ckadd_010/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/ckadd_010/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_cksub_001(self):
-
- cli_file = '/tmp/pipeline/cksub_001/cksub_001.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/cksub_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/cksub_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_invalidate_001(self):
-
- cli_file = '/tmp/pipeline/invalidate_001/invalidate_001.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/invalidate_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/invalidate_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_validate_001(self):
-
- cli_file = '/tmp/pipeline/validate_001/validate_001.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- # rule 0 test
- in_pcap_file = 'pipeline/validate_001/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/validate_001/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # rule 1 test
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
- # rule 2 test
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
- # rule 3 test
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
-
- def test_table_002(self):
-
- cli_file = '/tmp/pipeline/table_002/table_002.cli'
-
- cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
- self.dut.send_expect(cmd, "# ", 20)
- cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
- self.dut.send_expect(cmd, "# ", 20)
-
- cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
- self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
- sleep(2)
-
- # create TCP connection to the server
- SERVER_IP = '192.168.122.216'
- SERVER_PORT = 8086
- BUFFER_SIZE = 1024
-
- try:
- s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- except socket.error as err:
- print("socket creation failed with error %s" % (err))
-
- try:
- s.connect((SERVER_IP, SERVER_PORT))
- except socket.error as err:
- print("socket connection failed with error %s" % (err))
-
- sleep(0.1)
- msg = s.recv(BUFFER_SIZE)
- response = msg.decode()
- # print('Rxd: ' + response)
- if "pipeline>" not in response:
- s.close()
- self.verify(0, "CLI response error")
-
- # test empty table scenario
- in_pcap_file = 'pipeline/table_002/pcap_files/in_1.txt'
- out_pcap_file = 'pipeline/table_002/pcap_files/out_1.txt'
- filters = "tcp"
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- # test single rule scenario
- CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_2.txt'
- CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
- s.send(CLI_CMD.encode('utf-8'))
- sleep(0.1)
- msg = s.recv(BUFFER_SIZE)
- response = msg.decode()
- # print('Rxd: ' + response)
- if "pipeline>" not in response:
- s.close()
- self.verify(0, "CLI response error")
- filters = "tcp"
- in_pcap_file = 'pipeline/table_002/pcap_files/in_2.txt'
- out_pcap_file = 'pipeline/table_002/pcap_files/out_2.txt'
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- # test two rules scenario
- CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_3.txt'
- CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
- s.send(CLI_CMD.encode('utf-8'))
- sleep(0.1)
- msg = s.recv(BUFFER_SIZE)
- response = msg.decode()
- # print('Rxd: ' + response)
- if "pipeline>" not in response:
- s.close()
- self.verify(0, "CLI response error")
- filters = "tcp"
- in_pcap_file = 'pipeline/table_002/pcap_files/in_3.txt'
- out_pcap_file = 'pipeline/table_002/pcap_files/out_3.txt'
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- # delete one rule scenario
- CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_4_1.txt'
- CLI_CMD = 'pipeline PIPELINE0 table table_002_table update none {} none\n'.format(CMD_FILE)
- s.send(CLI_CMD.encode('utf-8'))
- sleep(0.1)
- msg = s.recv(BUFFER_SIZE)
- response = msg.decode()
- # print('Rxd: ' + response)
- if "pipeline>" not in response:
- s.close()
- self.verify(0, "CLI response error")
- filters = "tcp"
- in_pcap_file = 'pipeline/table_002/pcap_files/in_4_1.txt'
- out_pcap_file = 'pipeline/table_002/pcap_files/out_4_1.txt'
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- # delete all rules scenario
- CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_4_2.txt'
- CLI_CMD = 'pipeline PIPELINE0 table table_002_table update none {} none\n'.format(CMD_FILE)
- s.send(CLI_CMD.encode('utf-8'))
- sleep(0.1)
- msg = s.recv(BUFFER_SIZE)
- response = msg.decode()
- # print('Rxd: ' + response)
- if "pipeline>" not in response:
- s.close()
- self.verify(0, "CLI response error")
- filters = "tcp"
- in_pcap_file = 'pipeline/table_002/pcap_files/in_4_2.txt'
- out_pcap_file = 'pipeline/table_002/pcap_files/out_4_2.txt'
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- # action update scenario (restore one of the previously deleted rules and check the update)
- CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_5_1.txt'
- CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
- s.send(CLI_CMD.encode('utf-8'))
- sleep(0.1)
- msg = s.recv(BUFFER_SIZE)
- response = msg.decode()
- print('Rxd: ' + response)
- if "pipeline>" not in response:
- s.close()
- self.verify(0, "CLI response error")
- filters = "tcp"
- in_pcap_file = 'pipeline/table_002/pcap_files/in_5_1.txt'
- out_pcap_file = 'pipeline/table_002/pcap_files/out_5_1.txt'
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
- # action update scenario (change the action of restored rule and check the update)
- CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_5_2.txt'
- CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
- s.send(CLI_CMD.encode('utf-8'))
- sleep(0.1)
- msg = s.recv(BUFFER_SIZE)
- response = msg.decode()
- print('Rxd: ' + response)
- if "pipeline>" not in response:
- s.close()
- self.verify(0, "CLI response error")
- filters = "tcp"
- in_pcap_file = 'pipeline/table_002/pcap_files/in_5_1.txt'
- out_pcap_file = 'pipeline/table_002/pcap_files/out_5_1.txt'
- sniff_pkts = self.send_and_sniff_pkts(0, 1, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(1, 0, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(2, 3, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(3, 2, in_pcap_file, out_pcap_file, filters)
-
- # deafult action scenario [empty table]
- '''
- Empty table => Lookup MISS with default action executed
- '''
- CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_6_1.txt' # delete the previously added rule
- CLI_CMD = 'pipeline PIPELINE0 table table_002_table update none {} none\n'.format(CMD_FILE)
- s.send(CLI_CMD.encode('utf-8'))
- sleep(0.1)
- msg = s.recv(BUFFER_SIZE)
- response = msg.decode()
- print('Rxd: ' + response)
- if "pipeline>" not in response:
- s.close()
- self.verify(0, "CLI response error")
- filters = "tcp"
- in_pcap_file = 'pipeline/table_002/pcap_files/in_6_1.txt'
- out_pcap_file = 'pipeline/table_002/pcap_files/out_6_1.txt'
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- # deafult action scenario [table with one rule]
- '''
- Add key A => Lookup HIT for the right packet with the specific key associated action executed
- Lookup MISS for any other packets with default action executed
- '''
- CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_6_2.txt' # add a new rule
- CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
- s.send(CLI_CMD.encode('utf-8'))
- sleep(0.1)
- msg = s.recv(BUFFER_SIZE)
- response = msg.decode()
- print('Rxd: ' + response)
- if "pipeline>" not in response:
- s.close()
- self.verify(0, "CLI response error")
- filters = "tcp"
- in_pcap_file = 'pipeline/table_002/pcap_files/in_6_2.txt'
- out_pcap_file = 'pipeline/table_002/pcap_files/out_6_2.txt'
- sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
- sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
- s.close()
- sleep(1)
- cmd = "^C"
- self.dut.send_expect(cmd, "# ", 20)
+ out_pcap_1 = 'pipeline/met_001/pcap_files/out_41.txt'
+ out_pcap_2 = 'pipeline/met_001/pcap_files/out_42.txt'
+ out_pcap_3 = 'pipeline/met_001/pcap_files/out_43.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_met_002(self):
+
+ cli_file = '/tmp/pipeline/met_002/met_002.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap = ['pipeline/met_002/pcap_files/in_1.txt']
+ out_pcap_1 = 'pipeline/met_002/pcap_files/out_11.txt'
+ out_pcap_2 = 'pipeline/met_002/pcap_files/out_12.txt'
+ out_pcap_3 = 'pipeline/met_002/pcap_files/out_13.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ filters = ["tcp"] * 3
+ tx_port = [0]
+ rx_port = [0, 1, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+ out_pcap_1 = 'pipeline/met_002/pcap_files/out_21.txt'
+ out_pcap_2 = 'pipeline/met_002/pcap_files/out_22.txt'
+ out_pcap_3 = 'pipeline/met_002/pcap_files/out_23.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_met_003(self):
+
+ cli_file = '/tmp/pipeline/met_003/met_003.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap = ['pipeline/met_003/pcap_files/in_1.txt']
+ out_pcap_1 = 'pipeline/met_003/pcap_files/out_11.txt'
+ out_pcap_2 = 'pipeline/met_003/pcap_files/out_12.txt'
+ out_pcap_3 = 'pipeline/met_003/pcap_files/out_13.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ filters = ["tcp"] * 3
+ tx_port = [0]
+ rx_port = [0, 1, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+ out_pcap_1 = 'pipeline/met_003/pcap_files/out_21.txt'
+ out_pcap_2 = 'pipeline/met_003/pcap_files/out_22.txt'
+ out_pcap_3 = 'pipeline/met_003/pcap_files/out_23.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_met_004(self):
+
+ cli_file = '/tmp/pipeline/met_004/met_004.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap = ['pipeline/met_004/pcap_files/in_1.txt']
+ out_pcap_1 = 'pipeline/met_004/pcap_files/out_11.txt'
+ out_pcap_2 = 'pipeline/met_004/pcap_files/out_12.txt'
+ out_pcap_3 = 'pipeline/met_004/pcap_files/out_13.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ filters = ["tcp"] * 3
+ tx_port = [0]
+ rx_port = [0, 1, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+ out_pcap_1 = 'pipeline/met_004/pcap_files/out_21.txt'
+ out_pcap_2 = 'pipeline/met_004/pcap_files/out_22.txt'
+ out_pcap_3 = 'pipeline/met_004/pcap_files/out_23.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_met_005(self):
+
+ cli_file = '/tmp/pipeline/met_005/met_005.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap = ['pipeline/met_005/pcap_files/in_1.txt']
+ out_pcap_1 = 'pipeline/met_005/pcap_files/out_11.txt'
+ out_pcap_2 = 'pipeline/met_005/pcap_files/out_12.txt'
+ out_pcap_3 = 'pipeline/met_005/pcap_files/out_13.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ filters = ["tcp"] * 3
+ tx_port = [0]
+ rx_port = [0, 1, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+ out_pcap_1 = 'pipeline/met_005/pcap_files/out_21.txt'
+ out_pcap_2 = 'pipeline/met_005/pcap_files/out_22.txt'
+ out_pcap_3 = 'pipeline/met_005/pcap_files/out_23.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_met_006(self):
+
+ cli_file = '/tmp/pipeline/met_006/met_006.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap = ['pipeline/met_006/pcap_files/in_1.txt']
+ out_pcap_1 = 'pipeline/met_006/pcap_files/out_11.txt'
+ out_pcap_2 = 'pipeline/met_006/pcap_files/out_12.txt'
+ out_pcap_3 = 'pipeline/met_006/pcap_files/out_13.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ filters = ["tcp"] * 3
+ tx_port = [0]
+ rx_port = [0, 1, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+ out_pcap_1 = 'pipeline/met_006/pcap_files/out_21.txt'
+ out_pcap_2 = 'pipeline/met_006/pcap_files/out_22.txt'
+ out_pcap_3 = 'pipeline/met_006/pcap_files/out_23.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_met_007(self):
+
+ cli_file = '/tmp/pipeline/met_007/met_007.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap = ['pipeline/met_007/pcap_files/in_1.txt']
+ out_pcap_1 = 'pipeline/met_007/pcap_files/out_11.txt'
+ out_pcap_2 = 'pipeline/met_007/pcap_files/out_12.txt'
+ out_pcap_3 = 'pipeline/met_007/pcap_files/out_13.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ filters = ["tcp"] * 3
+ tx_port = [0]
+ rx_port = [0, 1, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+ out_pcap_1 = 'pipeline/met_007/pcap_files/out_21.txt'
+ out_pcap_2 = 'pipeline/met_007/pcap_files/out_22.txt'
+ out_pcap_3 = 'pipeline/met_007/pcap_files/out_23.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_met_008(self):
+
+ cli_file = '/tmp/pipeline/met_008/met_008.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap = ['pipeline/met_008/pcap_files/in_1.txt']
+ out_pcap_1 = 'pipeline/met_008/pcap_files/out_11.txt'
+ out_pcap_2 = 'pipeline/met_008/pcap_files/out_12.txt'
+ out_pcap_3 = 'pipeline/met_008/pcap_files/out_13.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ filters = ["tcp"] * 3
+ tx_port = [0]
+ rx_port = [0, 1, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+ out_pcap_1 = 'pipeline/met_008/pcap_files/out_21.txt'
+ out_pcap_2 = 'pipeline/met_008/pcap_files/out_22.txt'
+ out_pcap_3 = 'pipeline/met_008/pcap_files/out_23.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_met_009(self):
+
+ cli_file = '/tmp/pipeline/met_009/met_009.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap = ['pipeline/met_009/pcap_files/in_1.txt']
+ out_pcap_1 = 'pipeline/met_009/pcap_files/out_11.txt'
+ out_pcap_2 = 'pipeline/met_009/pcap_files/out_12.txt'
+ out_pcap_3 = 'pipeline/met_009/pcap_files/out_13.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ filters = ["tcp"] * 3
+ tx_port = [0]
+ rx_port = [0, 1, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+ out_pcap_1 = 'pipeline/met_009/pcap_files/out_21.txt'
+ out_pcap_2 = 'pipeline/met_009/pcap_files/out_22.txt'
+ out_pcap_3 = 'pipeline/met_009/pcap_files/out_23.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_met_010(self):
+
+ cli_file = '/tmp/pipeline/met_010/met_010.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap = ['pipeline/met_010/pcap_files/in_1.txt']
+ out_pcap_1 = 'pipeline/met_010/pcap_files/out_11.txt'
+ out_pcap_2 = 'pipeline/met_010/pcap_files/out_12.txt'
+ out_pcap_3 = 'pipeline/met_010/pcap_files/out_13.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ filters = ["tcp"] * 3
+ tx_port = [0]
+ rx_port = [0, 1, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+ out_pcap_1 = 'pipeline/met_010/pcap_files/out_21.txt'
+ out_pcap_2 = 'pipeline/met_010/pcap_files/out_22.txt'
+ out_pcap_3 = 'pipeline/met_010/pcap_files/out_23.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_met_011(self):
+
+ cli_file = '/tmp/pipeline/met_011/met_011.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap = ['pipeline/met_011/pcap_files/in_1.txt']
+ out_pcap_1 = 'pipeline/met_011/pcap_files/out_11.txt'
+ out_pcap_2 = 'pipeline/met_011/pcap_files/out_12.txt'
+ out_pcap_3 = 'pipeline/met_011/pcap_files/out_13.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ filters = ["tcp"] * 3
+ tx_port = [0]
+ rx_port = [0, 1, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+ out_pcap_1 = 'pipeline/met_011/pcap_files/out_21.txt'
+ out_pcap_2 = 'pipeline/met_011/pcap_files/out_22.txt'
+ out_pcap_3 = 'pipeline/met_011/pcap_files/out_23.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_met_012(self):
+
+ cli_file = '/tmp/pipeline/met_012/met_012.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap = ['pipeline/met_012/pcap_files/in_1.txt']
+ out_pcap_1 = 'pipeline/met_012/pcap_files/out_11.txt'
+ out_pcap_2 = 'pipeline/met_012/pcap_files/out_12.txt'
+ out_pcap_3 = 'pipeline/met_012/pcap_files/out_13.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ filters = ["tcp"] * 3
+ tx_port = [0]
+ rx_port = [0, 1, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+ out_pcap_1 = 'pipeline/met_012/pcap_files/out_21.txt'
+ out_pcap_2 = 'pipeline/met_012/pcap_files/out_22.txt'
+ out_pcap_3 = 'pipeline/met_012/pcap_files/out_23.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_met_013(self):
+
+ cli_file = '/tmp/pipeline/met_013/met_013.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap = ['pipeline/met_013/pcap_files/in_1.txt']
+ out_pcap_1 = 'pipeline/met_013/pcap_files/out_11.txt'
+ out_pcap_2 = 'pipeline/met_013/pcap_files/out_12.txt'
+ out_pcap_3 = 'pipeline/met_013/pcap_files/out_13.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ filters = ["tcp"] * 3
+ tx_port = [0]
+ rx_port = [0, 1, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_met_014(self):
+
+ cli_file = '/tmp/pipeline/met_014/met_014.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap = ['pipeline/met_014/pcap_files/in_1.txt']
+ out_pcap_1 = 'pipeline/met_014/pcap_files/out_11.txt'
+ out_pcap_2 = 'pipeline/met_014/pcap_files/out_12.txt'
+ out_pcap_3 = 'pipeline/met_014/pcap_files/out_13.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ filters = ["tcp"] * 3
+ tx_port = [0]
+ rx_port = [0, 1, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_met_015(self):
+
+ cli_file = '/tmp/pipeline/met_015/met_015.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap = ['pipeline/met_015/pcap_files/in_1.txt']
+ out_pcap_1 = 'pipeline/met_015/pcap_files/out_11.txt'
+ out_pcap_2 = 'pipeline/met_015/pcap_files/out_12.txt'
+ out_pcap_3 = 'pipeline/met_015/pcap_files/out_13.txt'
+ out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+ filters = ["tcp"] * 3
+ tx_port = [0]
+ rx_port = [0, 1, 2]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+ self.dut.send_expect("^C", "# ", 20)
+
+ '''
+ def test_tap_port_001(self):
+
+ cli_file = '/tmp/pipeline/tap_port_001/tap_port_001.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap = 'pipeline/tap_port_001/pcap_files/in_1.txt'
+ out_pcap = 'pipeline/tap_port_001/pcap_files/out_1.txt'
+ self.send_and_sniff_pkts(0, 0, in_pcap, out_pcap, "udp")
+ self.dut.send_expect("^C", "# ", 20)
+ '''
+
+ def test_ring_port_001(self):
+
+ cli_file = '/tmp/pipeline/ring_port_001/ring_port_001.cli'
+ self.run_dpdk_app(cli_file)
+
+ in_pcap = 'pipeline/ring_port_001/pcap_files/in_1.txt'
+ out_pcap = 'pipeline/ring_port_001/pcap_files/out_1.txt'
+ self.send_and_sniff_pkts(0, 1, in_pcap, out_pcap, "udp")
+ self.dut.send_expect("^C", "# ", 20)
+
+ def test_tencent_001(self):
+
+ cli_file = '/tmp/pipeline/tencent_001/tencent_001.cli'
+ self.run_dpdk_app(cli_file)
+ base_dir = 'pipeline/tencent_001/pcap_files/'
+
+ # TCP Packets
+ in_pcap = ['in_1.txt']
+ in_pcap = [base_dir + s for s in in_pcap]
+ out_pcap = ['out_11.txt', 'out_12.txt', 'out_13.txt', 'out_14.txt']
+ out_pcap = [base_dir + s for s in out_pcap]
+ filters = ["tcp"] * 4
+ tx_port = [0]
+ rx_port = [0, 1, 2, 3]
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+
+ # UDP Packets
+ in_pcap = ['in_2.txt']
+ in_pcap = [base_dir + s for s in in_pcap]
+ out_pcap = ['out_21.txt', 'out_22.txt', 'out_23.txt', 'out_24.txt']
+ out_pcap = [base_dir + s for s in out_pcap]
+ filters = ["udp port 200"] * 4
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+
+ # ICMP Packets
+ in_pcap = ['in_3.txt']
+ in_pcap = [base_dir + s for s in in_pcap]
+ out_pcap = ['out_31.txt', 'out_32.txt', 'out_33.txt', 'out_34.txt']
+ out_pcap = [base_dir + s for s in out_pcap]
+ filters = ["icmp"] * 4
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+
+ # IGMP Packets
+ in_pcap = ['in_4.txt']
+ in_pcap = [base_dir + s for s in in_pcap]
+ out_pcap = ['out_41.txt', 'out_42.txt', 'out_43.txt', 'out_44.txt']
+ out_pcap = [base_dir + s for s in out_pcap]
+ filters = ["igmp"] * 4
+ self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+ self.dut.send_expect("^C", "# ", 20)
def tear_down(self):
"""
--
1.8.3.1
next prev parent reply other threads:[~2021-04-21 10:14 UTC|newest]
Thread overview: 4+ messages / expand[flat|nested] mbox.gz Atom feed top
2021-04-21 10:17 [dts] [PATCH 0/2] add pipeline new features test scenarios Churchill Khangar
2021-04-21 10:17 ` [dts] [PATCH 1/2] dep: add pipeline test suite new feature dependencies Churchill Khangar
2021-04-21 10:17 ` Churchill Khangar [this message]
2021-04-29 8:56 ` [dts] [PATCH 0/2] add pipeline new features test scenarios Tu, Lijuan
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=1619000234-46133-3-git-send-email-churchill.khangar@intel.com \
--to=churchill.khangar@intel.com \
--cc=cristian.dumitrescu@intel.com \
--cc=dts@dpdk.org \
--cc=venkata.suresh.kumar.p@intel.com \
--cc=yogesh.jangra@intel.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
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).