[dts] [PATCH V1 2/2] multiple_pthread: Add test script.

[Lijuan Tu <lijuanx.a.tu@intel.com>]

The script only support Linux OS now.

Signed-off-by: Lijuan Tu <lijuanx.a.tu@intel.com>
---
 tests/TestSuite_multiple_pthread.py | 379 ++++++++++++++++++++++++++++++++++++
 1 file changed, 379 insertions(+)
 create mode 100644 tests/TestSuite_multiple_pthread.py

diff --git a/tests/TestSuite_multiple_pthread.py b/tests/TestSuite_multiple_pthread.py
new file mode 100644
index 0000000..7ebbd0c
--- /dev/null
+++ b/tests/TestSuite_multiple_pthread.py
@@ -0,0 +1,379 @@
+# BSD LICENSE
+#
+# Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in
+#     the documentation and/or other materials provided with the
+#     distribution.
+#   * Neither the name of Intel Corporation nor the names of its
+#     contributors may be used to endorse or promote products derived
+#     from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+DPDK Test suite.
+
+Test Multiple Pthread Feature
+
+"""
+import utils
+import dts
+import time
+import re
+import os
+import random
+import itertools
+from test_case import TestCase
+from pmd_output import PmdOutput
+
+
+class TestMultiplePthread(TestCase):
+
+    def set_up_all(self):
+        """
+        Run at the start of each test suite.
+        """
+        self.ports = self.dut.get_ports()
+        self.portmask = utils.create_mask(self.dut.get_ports(self.nic))
+        self.verify(len(self.ports) >= 2, "Insufficient number of ports.")
+        self.ports_socket = self.dut.get_numa_id(self.ports[0])
+        self.pmdout = PmdOutput(self.dut)
+
+    def set_up(self):
+        """
+        Run before each test case.
+        """
+        cores = self.dut.get_core_list('all')
+
+    def get_stats(self, portid):
+        """
+        Get packets number from port statistic.
+        """
+        output = PmdOutput(self.dut)
+        stats = output.get_pmd_stats(portid)
+        return stats
+
+    def check_forwarding(self, ports):
+        for i in range(len(ports)):
+            if i % 2 == 0:
+                self.send_packet(ports[i], ports[i + 1])
+                self.send_packet(ports[i + 1], ports[i])
+
+    def send_packet(self, txPort, rxPort):
+        """
+        Send packages according to parameters.
+        """
+        port0_stats = self.get_stats(txPort)
+        gp0tx_bytes = port0_stats['TX-packets']
+        port1_stats = self.get_stats(rxPort)
+        gp1rx_err = port1_stats['RX-errors']
+        gp1rx_bytes = port1_stats['RX-packets']
+        time.sleep(5)
+
+        itf = self.tester.get_interface(self.tester.get_local_port(txPort))
+
+        destMac = self.dut.get_mac_address(txPort)
+        self.tester.scapy_foreground()
+        self.tester.scapy_append(
+            'sendp([Ether(dst="%s", src="52:00:00:00:00:00")/IP()], iface="%s")'
+            % (destMac, itf))
+        self.tester.scapy_execute()
+        time.sleep(3)
+
+        port0_stats = self.get_stats(txPort)
+        p0tx_bytes = port0_stats['TX-packets']
+        port1_stats = self.get_stats(rxPort)
+        p1rx_err = port1_stats['RX-errors']
+        p1rx_bytes = port1_stats['RX-packets']
+        time.sleep(5)
+
+        p0tx_bytes -= gp0tx_bytes
+        p1rx_bytes -= gp1rx_bytes
+        p1rx_err -= gp1rx_err
+
+        self.verify(p0tx_bytes == p1rx_bytes,
+                    "Wrong TX pkts p0_tx=%d, p1_rx=%d"
+                    % (p0tx_bytes, p1rx_bytes))
+
+    def positive_test(self, lcores, corelist):
+
+        pmd_cmd = "./%s/app/testpmd --lcores='%s' -n 4 -- -i --portmask=%s" \
+            % (self.target, lcores, self.portmask)
+        out = self.dut.send_expect(pmd_cmd, "testpmd> ", 100)
+        self.dut.send_expect("set fwd mac", "testpmd>")
+        self.dut.send_expect("set corelist %s" % corelist, "testpmd> ")
+        self.dut.send_expect("start", "testpmd> ")
+        out = self.dut.send_expect("show config fwd", "testpmd> ")
+
+        if ',' in corelist:
+            corelist = re.split(",", corelist)
+            self.verify("Logical Core %s " % corelist[0] in out,
+                        "set corelist error:" + out)
+            print out
+            self.verify("Logical Core %s " % corelist[1] in out,
+                        "set corelist error:" + out)
+        else:
+            self.verify("Logical Core %s " % corelist in out,
+                        "set corelist error:" + out)
+        self.check_forwarding(self.ports)
+        cpu = '%cpu'
+        out = self.dut.alt_session.send_expect(
+            "ps -C testpmd -L -opid,tid,%s,psr,args | \
+               tail -n %s" % (cpu, corelist_num), "#")
+        result_scanner = "\d+\s+\d+\s+\w+.\w+\s+\d+\s./%s/app/testpmd" \
+            % self.target
+        scanner = re.compile(result_scanner, re.DOTALL)
+        m = scanner.finditer(out)
+
+        if m:
+            count = 0
+            for i in m:
+                text = i.group()
+                self.dut.alt_session.send_expect(
+                    "echo '%s' > /root/temp" % text, "#")
+                out = self.dut.alt_session.send_expect(
+                    "cat /root/temp | awk '{print $4}'", "#")
+                if out in cpus:
+                    count += 1
+            self.verify(count == corelist_num,
+                        "Threads running error:cpu is %s ." % count)
+
+        self.dut.send_expect("quit", "#")
+
+    def get_corelist(self, lcores):
+        global cpus
+        core_list = []
+        cpus = []
+        if lcores:
+            print lcores
+            lcore = re.split(' , ', lcores)
+            for i in lcore:
+                if '@' in i:
+                    l_core = re.split('@', i)
+                    l_core_0 = l_core[0]
+                    l_core_1 = l_core[1]
+
+                    if '-' in l_core_0:
+                        utils.regexp(i, r'(\d+)')
+                        l__core = re.compile(r'(\d+)').findall(l_core_0)
+                        l__core = map(int, l__core)
+                        if len(l__core) == 2:
+                            l__core.append(l__core[0] + 1)
+                            random_num = map(str, l__core)
+                            for num in random_num:
+                                core_list.append(num)
+                        elif l_core_0[2] == '-' or l_core_0[3] == '-':
+                            l__core.append(l__core[0] + 1)
+                            random_num = map(str, l__core)
+                            for num in random_num:
+                                core_list.append(num)
+                        else:
+                            if l__core[1] < l__core[2]:
+                                l__core.append(l__core[1] + 1)
+                                random_num = map(str, l__core)
+                                for num in random_num:
+                                    core_list.append(num)
+                            else:
+                                l__core.append(l__core[1] - 1)
+                                random_num = map(str, l__core)
+                                for num in random_num:
+                                    core_list.append(num)
+                    else:
+                        l__core = re.compile(r'(\d+)').findall(l_core_0)
+                        for num in l__core:
+                            core_list.append(num)
+                    if '-' in l_core_1:
+                        utils.regexp(i, r'(\d+)')
+                        l_cpu = re.compile(r'(\d+)').findall(l_core_1)
+                        l_cpu = map(int, l_cpu)
+                        if len(l_cpu) == 2:
+                            l_cpu.append(l_cpu[0] + 1)
+                            random_num = map(str, l_cpu)
+                            for num in random_num:
+                                cpus.append(num)
+                        elif l_core_1[2] == '-' or l_core_1[3] == '-':
+                            l_cpu.append(l_cpu[0] + 1)
+                            random_num = map(str, l_cpu)
+                            for num in random_num:
+                                cpus.append(num)
+                        else:
+                            l_cpu.append(l_cpu[1] - 1)
+                            random_num = map(str, l_cpu)
+                            for num in random_num:
+                                cpus.append(num)
+                    else:
+                        l_cpu = re.compile(r'(\d+)').findall(l_core_1)
+                        for num in l_cpu:
+                            cpus.append(num)
+                elif '-' in i and '@' not in i:
+                    utils.regexp(i, r'(\d+)')
+                    lcore_num = re.compile(r'(\d+)').findall(i)
+                    lcore_num = map(int, lcore_num)
+                    lcore_num.append(lcore_num[0] + 1)
+                    random_num = map(str, lcore_num)
+                    for num in random_num:
+                        core_list.append(num)
+                        cpus.append(num)
+                else:
+                    utils.regexp(i, r'(\d+)')
+                    random_num = re.compile(r'(\d+)').findall(i)
+                    for num in random_num:
+                        core_list.append(num)
+                        cpus.append(num)
+
+        core_list = list(set(core_list))
+        global corelist_num
+        corelist_num = len(core_list)
+
+        i = 0
+        core_list = map(int, core_list)
+        b = min(core_list)
+        while i < len(core_list):
+            if core_list[i] == b:
+                del core_list[i]
+                i -= 1
+            else:
+                i += 1
+
+        corelist = map(str, core_list)
+        print corelist, cpus
+        for i in itertools.combinations(core_list, 2):
+            i = ",".join(map(str, i))
+            corelist.append(i)
+        print corelist
+        for core in corelist:
+            self.positive_test(lcores, core)
+
+    def test_basic_operation(self):
+        """
+        Basic operation
+        """
+        # lcores = '0 @ random_num,(random_num,random_num) @ random_num'
+        cores = self.dut.get_core_list('all')
+        random.shuffle(cores)
+        random_num_0 = random.sample(cores, 2)
+        random_num_0[0] = '0'
+        lcore_0 = "@".join(random_num_0)
+        random_num_1 = tuple(map(int, random.sample(cores, 2)))
+        random_num_2 = random.randint(1, len(cores) - 1)
+        lcore_1 = "@".join(map(str, [random_num_1, random_num_2]))
+        lcores = " , ".join([lcore_0, lcore_1])
+
+        self.get_corelist(lcores)
+
+    def test_positive_test(self):
+        """
+        Positive Test
+        """
+        cores = self.dut.get_core_list('all')
+        random_num_0 = str(random.randint(1, len(cores) - 1))  # %d
+        random_num_1 = tuple(map(int, random.sample(cores, 2)))  # (%d,%d)
+        m = random.randint(1, len(cores) - 3)
+        random_num_2 = "-".join(map(str, [m, m + 2]))  # (%d-%d)
+        n = random.randint(1, len(cores) - 3)
+        random_num_3 = "-".join(map(str, [n, n + 2]))  # (%d-%d)
+        j = random.randint(3, len(cores) - 3)
+        random_num_4 = "-".join(map(str, [j, j - 2]))  # (%d-%d)
+        random_num_5 = str(random.randint(1, len(cores) - 1))  # %d
+
+        #lcore_0 = '0 @ %d,(%d-%d)@(%d-%d)'
+        core_0 = "@".join(['(%s)', '(%s)']) % (random_num_2, random_num_3)
+        core_1 = "@".join(['0', random_num_0])
+        lcore_0 = " , ".join([core_1, core_0])
+
+        #lcore_1 = '(0,CONFIG_RTE_MAX_LCORE-1)@(%d,%d)'
+        core_0 = ",".join(['0', cores[-1]])
+        lcore_1 = "@".join(map(str, ['(%s)', random_num_1])) % core_0
+
+        #lcore_2 = '(0,%d-%d)@(%d,%d)'
+        core_0 = ",".join(['0', random_num_2])
+        lcore_2 = "@".join(map(str, ['(%s)', random_num_1])) % core_0
+
+        #lcore_3 = '%d-%d,%d,%d-%d'
+        lcore_3 = " , ".join([random_num_3, random_num_0, random_num_2])
+
+        #lcore_4 = '%d, (%d-%d)@ %d'
+        core_0 = "@".join(['(%s)', random_num_0]) % random_num_2
+        lcore_4 = " , ".join(['2', core_0])
+
+        # lcore_5 = '(0,%d1-%d2)@(%d,%d)' %d1 > %d2
+        core_0 = ",".join(['0', random_num_4])
+        lcore_5 = "@".join(map(str, ['(%s)', random_num_1])) % core_0
+
+        #lcore_6 = '1 , 2@(0-2,6) , (2-4,6)@5 , (7,8)'
+        core__0 = ",".join([random_num_2, random_num_0])
+        core_0 = "@".join(['2', '(%s)']) % core__0
+        core__1 = ",".join([random_num_3, random_num_0])
+        core_1 = "@".join(['(%s)', random_num_5]) % core__1
+        lcore_6 = " , ".join(['1', core_0, core_1])
+
+        lcore_s = [lcore_0, lcore_1, lcore_2,
+                   lcore_3, lcore_4, lcore_5, lcore_6]
+        lcore_s = random.sample(lcore_s, 3)
+        print lcore_s
+        for lcores in lcore_s:
+            self.get_corelist(lcores)
+
+    def test_negative_test(self):
+        """
+        Negative Test
+        """
+        cores = map(int, self.dut.get_core_list('all'))
+
+        lcores = [
+            '(0-,%d-%d)@(%d,%d)' % (cores[1], cores[2], cores[-2], cores[-1]),
+            '(-1,%d-%d)@(%d,%d)' % (cores[1], cores[2], cores[-2], cores[-1]),
+            '(0,%d-%d-%d)@(%d,%d)' % (cores[1],
+                                      cores[2], cores[3], cores[-2], cores[-1]),
+            '(0,abcd)@(%d,%d)' % (cores[1], cores[2]),
+            '(0,%d-%d)@(1-,%d)' % (cores[1], cores[2], cores[-2]),
+            '(0,%d-%d)@(-1,%d)' % (cores[1], cores[2], cores[-2]),
+            '(0,%d-%d)@(%d,%d-%d-%d)' % (cores[1], cores[2],
+                                         cores[3], cores[-3], cores[-2], cores[-1]),
+            '(0,%d-%d)@(abc,%d)' % (cores[1], cores[2], cores[-2]),
+            '(0,%d-%d)@(%d,xyz)' % (cores[1], cores[2], cores[-2]),
+            '(0,%d-%d)=(%d,%d)' % (cores[1], cores[2], cores[-2], cores[-1]),
+            '%d,%d @ %d,(0-1,,%d))' % (cores[1],
+                                       cores[2], cores[-2], cores[-1]),
+            '[0-,%d-%d]@(%d,%d)' % (cores[1], cores[2], cores[-2], cores[-1]),
+            '(0-,%d-%d)@[%d,%d]' % (cores[1], cores[2], cores[-2], cores[-1]),
+            '%d-%d @ %d,%d @ %d-%d' % (cores[1], cores[2],
+                                       cores[2], cores[-3], cores[-2], cores[-1]),
+            '%d,,%d''%d--%d' % (cores[1], cores[2], cores[1], cores[2]),
+            '%d,,,%d''%d--%d' % (cores[1], cores[2], cores[1], cores[2])]
+
+        for lcore in lcores:
+            pmd_cmd = "./%s/app/testpmd --lcores='%s' -n 4 -- -i --portmask=%s" \
+                % (self.target, lcore, self.portmask)
+            self.dut.send_expect(pmd_cmd, "#", 100)
+
+    def tear_down(self):
+        """
+        Run after each test case.
+        """
+        self.dut.kill_all()
+
+    def tear_down_all(self):
+        """
+        Run after each test suite.
+        """
+        pass
-- 
2.5.0