@@ -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):
"""