[dts] [PATCH] framework: extend dts to run against installed dpdk packages

Jianbo Liu jianbo.liu at linaro.org
Thu Aug 24 04:02:29 CEST 2017


dts runs from dpdk source code by default, but sometimes users may want
to run tests on installed packages. This patch gives them an option to do that.

One of dpdk packaging is deb_dpdk, which is popular for ubuntu and other
debian-based system.

It's simple to do that, only to configure installed sdk path and testpmd path
in the parameters.

An example here is to run on deb_dpdk packages:
[Execution1]
crbs=<CRB IP Address>
drivername=igb_uio
test_suites=
    cmdline,
    ......,
targets=
    x86_64-native-linuxapp-gcc
parameters=nic_type=cfg:func=true:installed_dpdk_sdk=/usr/share/dpdk:testpmd_path=/usr/bin/testpmd

If installed_dpdk_sdk is set, dts will not compile the libs, kernel
modules and testpmd.

Signed-off-by: Jianbo Liu <jianbo.liu at linaro.org>
---
 framework/dts.py                                   | 11 ++++
 framework/pmd_output.py                            |  4 +-
 framework/project_dpdk.py                          | 61 +++++++++++++++++-----
 framework/settings.py                              |  3 ++
 tests/TestSuite_dynamic_config.py                  |  8 +--
 tests/TestSuite_fdir.py                            | 34 ++++++------
 tests/TestSuite_floating_veb.py                    | 50 +++++++++---------
 .../TestSuite_fortville_rss_granularity_config.py  | 24 ++++-----
 tests/TestSuite_ftag.py                            |  2 +-
 tests/TestSuite_hotplug.py                         |  4 +-
 tests/TestSuite_ipgre.py                           | 10 ++--
 tests/TestSuite_kni.py                             | 23 +++++---
 tests/TestSuite_link_status_interrupt.py           | 16 ++++--
 tests/TestSuite_nvgre.py                           | 22 ++++----
 tests/TestSuite_pmdpcap.py                         |  8 +--
 tests/TestSuite_pmdrss_hash.py                     | 18 +++----
 tests/TestSuite_pmdrssreta.py                      |  2 +-
 tests/TestSuite_qinq_filter.py                     | 32 ++++++------
 tests/TestSuite_short_live.py                      |  6 +--
 tests/TestSuite_tso.py                             |  6 +--
 tests/TestSuite_uni_pkt.py                         |  2 +-
 tests/TestSuite_unit_tests_dump.py                 |  6 +--
 tests/TestSuite_unit_tests_kni.py                  |  5 +-
 tests/TestSuite_veb_switch.py                      | 34 ++++++------
 tests/TestSuite_vhost_cuse_one_copy_one_vm.py      |  4 +-
 ...Suite_vhost_loopback_performance_virtio_user.py | 12 ++---
 tests/TestSuite_vhost_pmd_xstats.py                |  6 +--
 tests/TestSuite_vhost_qemu_pvp_performance.py      |  4 +-
 tests/TestSuite_vhost_user_live_migration.py       |  4 +-
 tests/TestSuite_vhost_user_one_copy_one_vm.py      |  4 +-
 tests/TestSuite_virtio_iperf.py                    | 10 +++-
 tests/TestSuite_vxlan.py                           | 38 ++++++--------
 tests/TestSuite_vxlan_sample.py                    |  2 +-
 33 files changed, 272 insertions(+), 203 deletions(-)

diff --git a/framework/dts.py b/framework/dts.py
index 931bf38..0325630 100644
--- a/framework/dts.py
+++ b/framework/dts.py
@@ -117,6 +117,17 @@ def dts_parse_param(config, section):
     else:
         settings.save_global_setting(settings.FUNC_SETTING, 'no')
 
+    if 'installed_dpdk_sdk' in paramDict and paramDict['installed_dpdk_sdk'] != '':
+        settings.save_global_setting(settings.INSTALLED_DPDK, 'yes')
+        settings.save_global_setting(settings.DPDK_SDK_PATH, paramDict['installed_dpdk_sdk'])
+
+        if 'testpmd_path' in paramDict and paramDict['testpmd_path'] != '':
+            settings.save_global_setting(settings.TESTPMD_PATH, paramDict['testpmd_path'])
+        else:
+            raise VerifyFailure("Please provide the testpmd path")
+    else:
+        settings.save_global_setting(settings.INSTALLED_DPDK, 'no')
+        settings.save_global_setting(settings.DPDK_SDK_PATH, "`pwd`")
 
 def dts_parse_config(config, section):
     """
diff --git a/framework/pmd_output.py b/framework/pmd_output.py
index 2d1e3d7..a44b22c 100644
--- a/framework/pmd_output.py
+++ b/framework/pmd_output.py
@@ -112,8 +112,8 @@ class PmdOutput():
         else:
             core_list = self.dut.get_core_list(cores, socket=socket)
         self.coremask = create_mask(core_list)
-        command = "./%s/app/testpmd -c %s -n %d %s -- -i %s" \
-            % (self.dut.target, self.coremask, self.dut.get_memory_channels(), eal_param, param)
+        command = "%s -c %s -n %d %s -- -i %s" \
+            % (self.dut.testpmd_path, self.coremask, self.dut.get_memory_channels(), eal_param, param)
         if "cavium" in self.dut.nic_type:
             # thunder nicvf does not support hw vlan filter, the application crashes
             # without this option added
diff --git a/framework/project_dpdk.py b/framework/project_dpdk.py
index 402ac8d..de7f64a 100644
--- a/framework/project_dpdk.py
+++ b/framework/project_dpdk.py
@@ -32,8 +32,9 @@
 import os
 import re
 
-from settings import NICS, load_global_setting, accepted_nic
+from settings import NICS, load_global_setting, accepted_nic, save_global_setting
 from settings import DPDK_RXMODE_SETTING, HOST_DRIVER_SETTING, HOST_DRIVER_MODE_SETTING
+from settings import INSTALLED_DPDK, DPDK_SDK_PATH, TESTPMD_PATH
 from ssh_connection import SSHConnection
 from crb import Crb
 from dut import Dut
@@ -63,11 +64,27 @@ class DPDKdut(Dut):
         self.target = target
         self.set_toolchain(target)
 
+        installed_dpdk = load_global_setting(INSTALLED_DPDK)
+
+        dpdk_sdk_path = load_global_setting(DPDK_SDK_PATH)
+        self.dpdk_sdk_path = dpdk_sdk_path
+
+        if installed_dpdk == "yes":
+            testpmd_path = load_global_setting(TESTPMD_PATH)
+            self.installed_igb_uio = "yes"
+            self.installed_kni = "yes"
+        else:
+            testpmd_path = "./%s/app/testpmd" % target
+            save_global_setting(TESTPMD_PATH, testpmd_path)
+            self.installed_igb_uio = "no"
+            self.installed_kni = "no"
+        self.testpmd_path = testpmd_path
+
         # set env variable
         # These have to be setup all the time. Some tests need to compile
         # example apps by themselves and will fail otherwise.
         self.send_expect("export RTE_TARGET=" + target, "#")
-        self.send_expect("export RTE_SDK=`pwd`", "#")
+        self.send_expect("export RTE_SDK=%s" % dpdk_sdk_path, "#")
 
         self.set_rxtx_mode()
 
@@ -114,7 +131,11 @@ class DPDKdut(Dut):
             out = self.send_expect("lsmod | grep igb_uio", "#")
             if "igb_uio" in out:
                 self.send_expect("rmmod -f igb_uio", "#", 70)
-            self.send_expect("insmod ./" + target + "/kmod/igb_uio.ko", "#", 60)
+
+            if self.installed_igb_uio == "yes":
+                self.send_expect("modprobe igb_uio", "#", 60)
+            else:
+                self.send_expect("insmod ./" + target + "/kmod/igb_uio.ko", "#", 60)
 
             out = self.send_expect("lsmod | grep igb_uio", "#")
             assert ("igb_uio" in out), "Failed to insmod igb_uio"
@@ -210,19 +231,23 @@ class DPDKdut(Dut):
         self.send_expect("rm -rf %s" % r'./app/test/test_pci_sysfs.res.o' , "#")
 
         # compile
-        out = self.send_expect("make -j install T=%s %s" % (target, extra_options), "# ", build_time)
-        #should not check test app compile status, because if test compile fail,
-        #all unit test can't exec, but others case will exec sucessfull 
-        self.build_install_dpdk_test_app(target, build_time)
-
-        if("Error" in out or "No rule to make" in out):
-            self.logger.error("ERROR - try without '-j'")
-            # if Error try to execute make without -j option
-            out = self.send_expect("make install T=%s %s" % (target, extra_options), "# ", 120)
+        installed_dpdk = load_global_setting(INSTALLED_DPDK)
+        if installed_dpdk == "yes":
+            self.build_install_dpdk_test_app(target, build_time)
+        else:
+            out = self.send_expect("make -j install T=%s %s" % (target, extra_options), "# ", build_time)
+            #should not check test app compile status, because if test compile fail,
+            #all unit test can't exec, but others case will exec sucessfull
             self.build_install_dpdk_test_app(target, build_time)
 
-        assert ("Error" not in out), "Compilation error..."
-        assert ("No rule to make" not in out), "No rule to make error..."
+            if("Error" in out or "No rule to make" in out):
+                self.logger.error("ERROR - try without '-j'")
+                # if Error try to execute make without -j option
+                out = self.send_expect("make install T=%s %s" % (target, extra_options), "# ", 120)
+                self.build_install_dpdk_test_app(target, build_time)
+
+            assert ("Error" not in out), "Compilation error..."
+            assert ("No rule to make" not in out), "No rule to make error..."
 
     def build_install_dpdk_freebsd(self, target, extra_options):
         """
@@ -257,8 +282,16 @@ class DPDKdut(Dut):
         if os_type == "freebsd":
             cmd_build_test = "make -j -C test/ CC=gcc48"
 
+        self.send_expect("export RTE_TARGET=" + self.target, "#")
+        self.send_expect("export RTE_SDK=" + self.dpdk_sdk_path, "#")
+
         self.send_expect(cmd_build_test, "# ", build_time)
         app_list = ['./test/test/test', './test/test-acl/testacl', './test/test-pipeline/testpipeline', './test/cmdline_test/cmdline_test']
+
+        installed_dpdk = load_global_setting(INSTALLED_DPDK)
+        if installed_dpdk == "yes":
+            self.send_expect('mkdir -p ./%s/app' % (target), "# ", 30)
+
         for app in app_list:
             self.send_expect('cp -f %s ./%s/app' % (app, target), "# ", 30)
          
diff --git a/framework/settings.py b/framework/settings.py
index e5b7746..b4bf37f 100644
--- a/framework/settings.py
+++ b/framework/settings.py
@@ -212,6 +212,9 @@ DPDK_RXMODE_SETTING = "DTS_DPDK_RXMODE"
 DTS_ERROR_ENV = "DTS_RUNNING_ERROR"
 DTS_CFG_FOLDER = "DTS_CFG_FOLDER"
 
+INSTALLED_DPDK = "INSTALLED_DPDK"
+DPDK_SDK_PATH = "DPDK_SDK_PATH"
+TESTPMD_PATH = "TESTPMD_PATH"
 
 """
 DTS global error table
diff --git a/tests/TestSuite_dynamic_config.py b/tests/TestSuite_dynamic_config.py
index 699c303..4244b52 100644
--- a/tests/TestSuite_dynamic_config.py
+++ b/tests/TestSuite_dynamic_config.py
@@ -75,8 +75,8 @@ class TestDynamicConfig(TestCase):
         self.portMask = utils.create_mask(self.dut_ports[:2])
 
         # launch app
-        cmd = "./%s/app/testpmd -c %s -n 3 -- -i --rxpt=0 \
-        --rxht=0 --rxwt=0 --txpt=39 --txht=0 --txwt=0 --portmask=%s" % (self.target, self.coreMask, self.portMask)
+        cmd = "%s -c %s -n 3 -- -i --rxpt=0 \
+        --rxht=0 --rxwt=0 --txpt=39 --txht=0 --txwt=0 --portmask=%s" % (self.dut.testpmd_path, self.coreMask, self.portMask)
 
 	if "cavium" in self.dut.nic_type:
             cmd += " --disable-hw-vlan-filter"
@@ -116,8 +116,8 @@ class TestDynamicConfig(TestCase):
         """
         Run before each test case.
         """
-        cmd = "./%s/app/testpmd -c %s -n 3 -- -i --rxpt=0 \
-        --rxht=0 --rxwt=0 --txpt=39 --txht=0 --txwt=0 --portmask=%s" % (self.target, self.coreMask, self.portMask)
+        cmd = "%s -c %s -n 3 -- -i --rxpt=0 \
+        --rxht=0 --rxwt=0 --txpt=39 --txht=0 --txwt=0 --portmask=%s" % (self.dut.testpmd_path, self.coreMask, self.portMask)
 
 	if "cavium" in self.dut.nic_type:
             cmd += " --disable-hw-vlan-filter"
diff --git a/tests/TestSuite_fdir.py b/tests/TestSuite_fdir.py
index 44f1e96..4f034b7 100644
--- a/tests/TestSuite_fdir.py
+++ b/tests/TestSuite_fdir.py
@@ -241,7 +241,7 @@ class TestFdir(TestCase, IxiaPacketGenerator):
         """
 
         self.dut.kill_all()
-        self.dut.send_expect("./%s/app/testpmd -c %s -n 4 -- -i --portmask=%s --disable-rss  --rxq=4 --txq=4 --nb-cores=4  --nb-ports=1 --pkt-filter-mode=perfect" % (self.target, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
+        self.dut.send_expect("%s -c %s -n 4 -- -i --portmask=%s --disable-rss  --rxq=4 --txq=4 --nb-cores=4  --nb-ports=1 --pkt-filter-mode=perfect" % (self.dut.testpmd_path, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
         self.dut.send_expect("set verbose 1", "testpmd>")
         self.dut.send_expect("set fwd rxonly", "testpmd>")
 
@@ -317,10 +317,10 @@ class TestFdir(TestCase, IxiaPacketGenerator):
         self.dut.kill_all()
         if self.nic in ["niantic"]:
             # Niantic ipv6 only support signature mode
-            self.dut.send_expect("./%s/app/testpmd -c %s -n 4 -- -i --portmask=%s --disable-rss  --rxq=4 --txq=4 --nb-cores=4  --nb-ports=1 --pkt-filter-mode=signature" % (self.target, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
+            self.dut.send_expect("%s -c %s -n 4 -- -i --portmask=%s --disable-rss  --rxq=4 --txq=4 --nb-cores=4  --nb-ports=1 --pkt-filter-mode=signature" % (self.dut.testpmd_path, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
         elif self.nic in ["fortville_eagle", "fortville_spirit", "fortville_spirit_single", "fortpark_TLV", "fortville_25g"]:
             # Fortville ipv6 support perfect mode
-            self.dut.send_expect("./%s/app/testpmd -c %s -n 4 -- -i --portmask=%s --disable-rss  --rxq=4 --txq=4 --nb-cores=4  --nb-ports=1 --pkt-filter-mode=perfect" % (self.target, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
+            self.dut.send_expect("%s -c %s -n 4 -- -i --portmask=%s --disable-rss  --rxq=4 --txq=4 --nb-cores=4  --nb-ports=1 --pkt-filter-mode=perfect" % (self.dut.testpmd_path, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
         self.dut.send_expect("set verbose 1", "testpmd>")
         self.dut.send_expect("set fwd rxonly", "testpmd>")
 
@@ -388,7 +388,7 @@ class TestFdir(TestCase, IxiaPacketGenerator):
     def test_fdir_noflexword_drop_ipv4(self):
         # drop command testing
         self.dut.kill_all()
-        self.dut.send_expect("./%s/app/testpmd -c %s -n 4 -- -i --portmask=%s --disable-rss  --rxq=4 --txq=4 --nb-cores=4  --nb-ports=1 --pkt-filter-mode=perfect" % (self.target, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
+        self.dut.send_expect("%s -c %s -n 4 -- -i --portmask=%s --disable-rss  --rxq=4 --txq=4 --nb-cores=4  --nb-ports=1 --pkt-filter-mode=perfect" % (self.dut.testpmd_path, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
         self.dut.send_expect("set verbose 1", "testpmd>")
         self.dut.send_expect("set fwd rxonly", "testpmd>")
 
@@ -466,7 +466,7 @@ class TestFdir(TestCase, IxiaPacketGenerator):
             # drop command testing
             self.dut.kill_all()
 
-            self.dut.send_expect("./%s/app/testpmd -c %s -n 4 -- -i --portmask=%s --disable-rss  --rxq=4 --txq=4 --nb-cores=4  --nb-ports=1 --pkt-filter-mode=perfect" % (self.target, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
+            self.dut.send_expect("%s -c %s -n 4 -- -i --portmask=%s --disable-rss  --rxq=4 --txq=4 --nb-cores=4  --nb-ports=1 --pkt-filter-mode=perfect" % (self.dut.testpmd_path, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
             self.dut.send_expect("set verbose 1", "testpmd>")
             self.dut.send_expect("set fwd rxonly", "testpmd>")
 
@@ -523,7 +523,7 @@ class TestFdir(TestCase, IxiaPacketGenerator):
 
         self.dut.kill_all()
         # fwd testing with flexword
-        self.dut.send_expect("./%s/app/testpmd -c %s -n 4 -- -i --portmask=%s --disable-rss --rxq=4 --txq=4 --nb-cores=4 --nb-ports=1 --pkt-filter-mode=perfect" % (self.target, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
+        self.dut.send_expect("%s -c %s -n 4 -- -i --portmask=%s --disable-rss --rxq=4 --txq=4 --nb-cores=4 --nb-ports=1 --pkt-filter-mode=perfect" % (self.dut.testpmd_path, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
         self.dut.send_expect("set verbose 1", "testpmd>")
         self.dut.send_expect("set fwd rxonly", "testpmd>")
 
@@ -602,10 +602,10 @@ class TestFdir(TestCase, IxiaPacketGenerator):
         # fwd testing with flexword
         if self.nic in ["niantic"]:
             # Niantic ipv6 only support signature mode
-            self.dut.send_expect("./%s/app/testpmd -c %s -n 4 -- -i --portmask=%s --disable-rss  --rxq=4 --txq=4 --nb-cores=4  --nb-ports=1 --pkt-filter-mode=signature" % (self.target, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
+            self.dut.send_expect("%s -c %s -n 4 -- -i --portmask=%s --disable-rss  --rxq=4 --txq=4 --nb-cores=4  --nb-ports=1 --pkt-filter-mode=signature" % (self.dut.testpmd_path, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
         elif self.nic in ["fortville_eagle", "fortville_spirit", "fortville_spirit_single", "fortpark_TLV", "fortville_25g"]:
             # fortville ipv6 support perfect mode
-            self.dut.send_expect("./%s/app/testpmd -c %s -n 4 -- -i --portmask=%s --disable-rss --rxq=4 --txq=4 --nb-cores=4 --nb-ports=1 --pkt-filter-mode=perfect" % (self.target, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
+            self.dut.send_expect("%s -c %s -n 4 -- -i --portmask=%s --disable-rss --rxq=4 --txq=4 --nb-cores=4 --nb-ports=1 --pkt-filter-mode=perfect" % (self.dut.testpmd_path, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
         self.dut.send_expect("set verbose 1", "testpmd>")
         self.dut.send_expect("set fwd rxonly", "testpmd>")
 
@@ -672,7 +672,7 @@ class TestFdir(TestCase, IxiaPacketGenerator):
     def test_fdir_flexword_drop_ipv4(self):
 
         # drop testing with flexword
-        self.dut.send_expect("./%s/app/testpmd -c %s -n 4 -- -i --portmask=%s --disable-rss --rxq=4 --txq=4 --nb-cores=4 --nb-ports=1 --pkt-filter-mode=perfect" % (self.target, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
+        self.dut.send_expect("%s -c %s -n 4 -- -i --portmask=%s --disable-rss --rxq=4 --txq=4 --nb-cores=4 --nb-ports=1 --pkt-filter-mode=perfect" % (self.dut.testpmd_path, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
         self.dut.send_expect("set verbose 1", "testpmd>")
         self.dut.send_expect("set fwd rxonly", "testpmd>")
 
@@ -730,7 +730,7 @@ class TestFdir(TestCase, IxiaPacketGenerator):
         # Niantic is not support in drop ipv6
         if (self.nic in ["fortville_eagle", "fortville_spirit", "fortville_spirit_single", "fortpark_TLV", "fortville_25g"]):
             # drop testing with flexword
-            self.dut.send_expect("./%s/app/testpmd -c %s -n 4 -- -i --portmask=%s --disable-rss --rxq=4 --txq=4 --nb-cores=4 --nb-ports=1 --pkt-filter-mode=perfect" % (self.target, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
+            self.dut.send_expect("%s -c %s -n 4 -- -i --portmask=%s --disable-rss --rxq=4 --txq=4 --nb-cores=4 --nb-ports=1 --pkt-filter-mode=perfect" % (self.dut.testpmd_path, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
             self.dut.send_expect("set verbose 1", "testpmd>")
             self.dut.send_expect("set fwd rxonly", "testpmd>")
 
@@ -773,7 +773,7 @@ class TestFdir(TestCase, IxiaPacketGenerator):
         if not self.nic in ["fortville_eagle", "fortville_spirit", "fortville_spirit_single", "fortville_25g"]:
             self.verify(False, "This case only support fortville nic")
         self.dut.kill_all()
-        self.dut.send_expect("./%s/app/testpmd -c %s -n 4 -- -i --portmask=%s --disable-rss --rxq=4 --txq=4 --nb-cores=4 --nb-ports=1 --pkt-filter-mode=perfect" % (self.target, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
+        self.dut.send_expect("%s -c %s -n 4 -- -i --portmask=%s --disable-rss --rxq=4 --txq=4 --nb-cores=4 --nb-ports=1 --pkt-filter-mode=perfect" % (self.dut.testpmd_path, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
         self.dut.send_expect("set verbose 1", "testpmd>")
         self.dut.send_expect("set fwd rxonly", "testpmd>")
 
@@ -894,7 +894,7 @@ class TestFdir(TestCase, IxiaPacketGenerator):
         if not self.nic in ["fortville_eagle", "fortville_spirit", "fortville_spirit_single", "fortville_25g"]:
             self.verify(False, "This case only support fortville nic")
         self.dut.kill_all()
-        self.dut.send_expect("./%s/app/testpmd -c %s -n 4 -- -i --portmask=%s --disable-rss --rxq=4 --txq=4 --nb-cores=4 --nb-ports=1 --pkt-filter-mode=perfect" % (self.target, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
+        self.dut.send_expect("%s -c %s -n 4 -- -i --portmask=%s --disable-rss --rxq=4 --txq=4 --nb-cores=4 --nb-ports=1 --pkt-filter-mode=perfect" % (self.dut.testpmd_path, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
         self.dut.send_expect("set verbose 1", "testpmd>")
         self.dut.send_expect("set fwd rxonly", "testpmd>")
 
@@ -1015,7 +1015,7 @@ class TestFdir(TestCase, IxiaPacketGenerator):
         if not self.nic in ["fortville_eagle", "fortville_spirit", "fortville_spirit_single", "fortville_25g"]:
             self.verify(False, "This case only support fortville nic")
         self.dut.kill_all()
-        self.dut.send_expect("./%s/app/testpmd -c %s -n 4 -- -i --portmask=%s --disable-rss --rxq=4 --txq=4 --nb-cores=4 --nb-ports=1 --pkt-filter-mode=perfect" % (self.target, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
+        self.dut.send_expect("%s -c %s -n 4 -- -i --portmask=%s --disable-rss --rxq=4 --txq=4 --nb-cores=4 --nb-ports=1 --pkt-filter-mode=perfect" % (self.dut.testpmd_path, self.coreMask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
         self.dut.send_expect("set verbose 1", "testpmd>")
         self.dut.send_expect("set fwd rxonly", "testpmd>")
 
@@ -1110,7 +1110,7 @@ class TestFdir(TestCase, IxiaPacketGenerator):
 
         self.dut.kill_all()
 
-        self.dut.send_expect("./%s/app/testpmd -c %s -n 4 -- -i --portmask=%s --disable-rss  --rxq=8 --txq=8 --nb-cores=16 --nb-ports=2  --pkt-filter-mode=perfect" % (self.target, self.all_cores_mask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
+        self.dut.send_expect("%s -c %s -n 4 -- -i --portmask=%s --disable-rss  --rxq=8 --txq=8 --nb-cores=16 --nb-ports=2  --pkt-filter-mode=perfect" % (self.dut.testpmd_path, self.all_cores_mask, utils.create_mask([self.dut_ports[0]])), "testpmd>", 120)
 
         self.dut.send_expect("set verbose 1", "testpmd>")
         self.dut.send_expect("set fwd rxonly", "testpmd>")
@@ -1198,13 +1198,13 @@ class TestFdir(TestCase, IxiaPacketGenerator):
             port_mask = utils.create_mask([self.dut_ports[0], self.dut_ports[1]])
 
             if test_type == "fdir_disable":
-                command_line = "./%s/app/testpmd -c 0xff00ff -n %d -- -i --rxq=2 --txq=2  --rxd=512 --txd=512 --burst=32 --rxfreet=64 --txfreet=64 --mbcache=256 \
+                command_line = "%s -c 0xff00ff -n %d -- -i --rxq=2 --txq=2  --rxd=512 --txd=512 --burst=32 --rxfreet=64 --txfreet=64 --mbcache=256 \
                 --portmask=%s --nb-cores=4 --nb-ports=2 --rss-ip\
                 " % (self.target, self.dut.get_memory_channels(), port_mask)
             else:
-                command_line = "./%s/app/testpmd -c 0xff00ff -n %d -- -i --rxq=2 --txq=2  --rxd=512 --txd=512 --burst=32 --rxfreet=64 --txfreet=64 --mbcache=256 \
+                command_line = "%s -c 0xff00ff -n %d -- -i --rxq=2 --txq=2  --rxd=512 --txd=512 --burst=32 --rxfreet=64 --txfreet=64 --mbcache=256 \
                 --portmask=%s --nb-cores=4 --nb-ports=2 --rss-ip\
-                --pkt-filter-mode=perfect" % (self.target, self.dut.get_memory_channels(), port_mask)
+                --pkt-filter-mode=perfect" % (self.dut.testpmd_path, self.dut.get_memory_channels(), port_mask)
 
             info = "Executing PMD using %s\n" % test_cycle['cores']
             self.logger.info(info)
diff --git a/tests/TestSuite_floating_veb.py b/tests/TestSuite_floating_veb.py
index 3dfb66f..6a8cfdf 100644
--- a/tests/TestSuite_floating_veb.py
+++ b/tests/TestSuite_floating_veb.py
@@ -212,12 +212,12 @@ class TestVEBSwitching(TestCase):
         """
         # VF->PF
         self.setup_env(driver=self.drivername, vf_num=1)
-        self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 -w %s,enable_floating_veb=1 --file-prefix=test1 -- -i" % (self.target, self.pf_pci), "testpmd>", 120)
+        self.dut.send_expect("%s -c 0xf -n 4 --socket-mem 1024,1024 -w %s,enable_floating_veb=1 --file-prefix=test1 -- -i" % (self.dut.testpmd_path, self.pf_pci), "testpmd>", 120)
         self.dut.send_expect("set fwd rxonly", "testpmd>")
         self.dut.send_expect("set promisc all off", "testpmd>")
         self.dut.send_expect("start", "testpmd>")
         time.sleep(2)
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[0].pci, self.pf_mac_address), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.sriov_vfs_port[0].pci, self.pf_mac_address), "testpmd>", 120)
         self.session_secondary.send_expect("set fwd txonly", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
         self.session_secondary.send_expect("start", "testpmd>")
@@ -236,11 +236,11 @@ class TestVEBSwitching(TestCase):
         time.sleep(2)
 
         #PF->VF
-        self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 -w %s,enable_floating_veb=1 --file-prefix=test1 -- -i --eth-peer=0,%s" % (self.target, self.pf_pci, self.vf0_mac), "testpmd>", 120)
+        self.dut.send_expect("%s -c 0xf -n 4 --socket-mem 1024,1024 -w %s,enable_floating_veb=1 --file-prefix=test1 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.pf_pci, self.vf0_mac), "testpmd>", 120)
         self.dut.send_expect("set fwd txonly", "testpmd>")
         self.dut.send_expect("set promisc all off", "testpmd>")
 
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.target, self.sriov_vfs_port[0].pci), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.dut.testpmd_path, self.sriov_vfs_port[0].pci), "testpmd>", 120)
         self.session_secondary.send_expect("mac_addr add 0 %s" % self.vf0_mac, "testpmd>")
         self.session_secondary.send_expect("set fwd rxonly", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
@@ -262,13 +262,13 @@ class TestVEBSwitching(TestCase):
         time.sleep(2)
 
         #outside world ->VF
-        self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 -w %s,enable_floating_veb=1 --file-prefix=test1 -- -i --eth-peer=0,%s" % (self.target, self.pf_pci, self.vf0_mac), "testpmd>", 120)
+        self.dut.send_expect("%s -c 0xf -n 4 --socket-mem 1024,1024 -w %s,enable_floating_veb=1 --file-prefix=test1 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.pf_pci, self.vf0_mac), "testpmd>", 120)
         self.dut.send_expect("set fwd mac", "testpmd>")
         self.dut.send_expect("set promisc all on", "testpmd>")
         self.dut.send_expect("start", "testpmd>")
         time.sleep(2)
 
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.target, self.sriov_vfs_port[0].pci), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.dut.testpmd_path, self.sriov_vfs_port[0].pci), "testpmd>", 120)
         self.session_secondary.send_expect("mac_addr add 0 %s" % self.vf0_mac, "testpmd>")
         self.session_secondary.send_expect("set fwd mac", "testpmd>")
         self.session_secondary.send_expect("set promisc all on", "testpmd>")
@@ -293,18 +293,18 @@ class TestVEBSwitching(TestCase):
         # PF link up, VF0->VF1
         self.setup_env(driver=self.drivername, vf_num=2)
         # start PF
-        self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 -w %s,enable_floating_veb=1 --file-prefix=test1 -- -i" % (self.target, self.pf_pci), "testpmd>", 120)
+        self.dut.send_expect("%s -c 0xf -n 4 --socket-mem 1024,1024 -w %s,enable_floating_veb=1 --file-prefix=test1 -- -i" % (self.dut.testpmd_path, self.pf_pci), "testpmd>", 120)
         self.dut.send_expect("port start all", "testpmd>")
         time.sleep(2)
         # start VF0
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.target, self.sriov_vfs_port[0].pci), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.dut.testpmd_path, self.sriov_vfs_port[0].pci), "testpmd>", 120)
         self.session_secondary.send_expect("mac_addr add 0 %s" % self.vf0_mac, "testpmd>")
         self.session_secondary.send_expect("set fwd rxonly", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
         self.session_secondary.send_expect("start", "testpmd>")
         time.sleep(2)
         # start VF1
-        self.session_third.send_expect("./%s/app/testpmd -c 0xf00 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test3 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[1].pci, self.vf0_mac), "testpmd>", 120)
+        self.session_third.send_expect("%s -c 0xf00 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test3 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.sriov_vfs_port[1].pci, self.vf0_mac), "testpmd>", 120)
         self.session_third.send_expect("set fwd txonly", "testpmd>")
         self.session_third.send_expect("set promisc all off", "testpmd>")
         self.session_third.send_expect("start", "testpmd>")
@@ -354,17 +354,17 @@ class TestVEBSwitching(TestCase):
         """
         self.setup_env(driver=self.drivername, vf_num=4)
         # start PF
-        self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 \"-w %s,enable_floating_veb=1,floating_veb_list=0;2-3\" --file-prefix=test1 -- -i" % (self.target, self.pf_pci), "testpmd>", 120)
+        self.dut.send_expect("%s -c 0xf -n 4 --socket-mem 1024,1024 \"-w %s,enable_floating_veb=1,floating_veb_list=0;2-3\" --file-prefix=test1 -- -i" % (self.dut.testpmd_path, self.pf_pci), "testpmd>", 120)
         self.dut.send_expect("port start all", "testpmd>")
         time.sleep(2)
         # VF1->VF0
         # start VF0
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[0].pci, self.vf1_mac), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.sriov_vfs_port[0].pci, self.vf1_mac), "testpmd>", 120)
         self.session_secondary.send_expect("mac_addr add 0 %s" % self.vf0_mac, "testpmd>")
         self.session_secondary.send_expect("set fwd rxonly", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
         # start VF1
-        self.session_third.send_expect("./%s/app/testpmd -c 0xf00 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test3 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[1].pci, self.vf0_mac), "testpmd>", 120)
+        self.session_third.send_expect("%s -c 0xf00 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test3 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.sriov_vfs_port[1].pci, self.vf0_mac), "testpmd>", 120)
         self.session_secondary.send_expect("mac_addr add 0 %s" % self.vf1_mac, "testpmd>")
         self.session_third.send_expect("set fwd txonly", "testpmd>")
         self.session_third.send_expect("set promisc all off", "testpmd>")
@@ -407,12 +407,12 @@ class TestVEBSwitching(TestCase):
         # VF0->VF2
         # start VF0
         self.dut.send_expect("port start all", "testpmd>")
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[0].pci, self.vf2_mac), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.sriov_vfs_port[0].pci, self.vf2_mac), "testpmd>", 120)
         self.session_secondary.send_expect("mac_addr add 0 %s" % self.vf0_mac, "testpmd>")
         self.session_secondary.send_expect("set fwd txonly", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
         # start VF2
-        self.session_third.send_expect("./%s/app/testpmd -c 0xf00 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test3 -- -i" % (self.target, self.sriov_vfs_port[2].pci), "testpmd>", 120)
+        self.session_third.send_expect("%s -c 0xf00 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test3 -- -i" % (self.dut.testpmd_path, self.sriov_vfs_port[2].pci), "testpmd>", 120)
         self.session_third.send_expect("mac_addr add 0 %s" % self.vf2_mac, "testpmd>")
         self.session_third.send_expect("set fwd rxonly", "testpmd>")
         self.session_third.send_expect("set promisc all off", "testpmd>")
@@ -441,12 +441,12 @@ class TestVEBSwitching(TestCase):
         # VF3->VF2
         # start VF3
         self.dut.send_expect("port start all", "testpmd>")
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[3].pci, self.vf2_mac), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.sriov_vfs_port[3].pci, self.vf2_mac), "testpmd>", 120)
         self.session_secondary.send_expect("mac_addr add 0 %s" % self.vf0_mac, "testpmd>")
         self.session_secondary.send_expect("set fwd txonly", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
         # start VF2
-        self.session_third.send_expect("./%s/app/testpmd -c 0xf00 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test3 -- -i" % (self.target, self.sriov_vfs_port[2].pci), "testpmd>", 120)
+        self.session_third.send_expect("%s -c 0xf00 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test3 -- -i" % (self.dut.testpmd_path, self.sriov_vfs_port[2].pci), "testpmd>", 120)
         self.session_third.send_expect("mac_addr add 0 %s" % self.vf2_mac, "testpmd>")
         self.session_third.send_expect("set fwd rxonly", "testpmd>")
         self.session_third.send_expect("set promisc all off", "testpmd>")
@@ -483,12 +483,12 @@ class TestVEBSwitching(TestCase):
         """
         self.setup_env(driver=self.drivername, vf_num=4)
         # VF0->PF
-        self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 \"-w %s,enable_floating_veb=1,floating_veb_list=0;3\" --file-prefix=test1 -- -i" % (self.target, self.pf_pci), "testpmd>", 120)
+        self.dut.send_expect("%s -c 0xf -n 4 --socket-mem 1024,1024 \"-w %s,enable_floating_veb=1,floating_veb_list=0;3\" --file-prefix=test1 -- -i" % (self.dut.testpmd_path, self.pf_pci), "testpmd>", 120)
         self.dut.send_expect("set fwd rxonly", "testpmd>")
         self.dut.send_expect("set promisc all off", "testpmd>")
         self.dut.send_expect("start", "testpmd>")
         time.sleep(2)
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[0].pci, self.pf_mac_address), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.sriov_vfs_port[0].pci, self.pf_mac_address), "testpmd>", 120)
         self.session_secondary.send_expect("set fwd txonly", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
         self.session_secondary.send_expect("start", "testpmd>")
@@ -505,7 +505,7 @@ class TestVEBSwitching(TestCase):
         time.sleep(2)
 
         # VF1->PF
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[1].pci, self.pf_mac_address), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.sriov_vfs_port[1].pci, self.pf_mac_address), "testpmd>", 120)
         self.session_secondary.send_expect("set fwd txonly", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
         self.dut.send_expect("start", "testpmd>")
@@ -530,7 +530,7 @@ class TestVEBSwitching(TestCase):
         self.dut.send_expect("start", "testpmd>")
         time.sleep(2)
 
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.target, self.sriov_vfs_port[0].pci), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.dut.testpmd_path, self.sriov_vfs_port[0].pci), "testpmd>", 120)
         self.session_secondary.send_expect("mac_addr add 0 %s" % self.vf0_mac, "testpmd>")
         self.session_secondary.send_expect("set fwd mac", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
@@ -548,7 +548,7 @@ class TestVEBSwitching(TestCase):
         time.sleep(2)
 
         # tester->VF1
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.target, self.sriov_vfs_port[1].pci), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.dut.testpmd_path, self.sriov_vfs_port[1].pci), "testpmd>", 120)
         self.session_secondary.send_expect("mac_addr add 0 %s" % self.vf1_mac, "testpmd>")
         self.session_secondary.send_expect("set fwd mac", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
@@ -566,14 +566,14 @@ class TestVEBSwitching(TestCase):
         time.sleep(2)
 
         # VF2->VF1
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.target, self.sriov_vfs_port[1].pci), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.dut.testpmd_path, self.sriov_vfs_port[1].pci), "testpmd>", 120)
         self.session_secondary.send_expect("mac_addr add 0 %s" % self.vf1_mac, "testpmd>")
         self.session_secondary.send_expect("set fwd rxonly", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
         self.session_secondary.send_expect("start", "testpmd>")
         time.sleep(2)
 
-        self.session_third.send_expect("./%s/app/testpmd -c 0xf00 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test3 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[2].pci, self.vf1_mac), "testpmd>", 120)
+        self.session_third.send_expect("%s -c 0xf00 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test3 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.sriov_vfs_port[2].pci, self.vf1_mac), "testpmd>", 120)
         self.session_third.send_expect("set fwd txonly", "testpmd>")
         self.session_third.send_expect("set promisc all off", "testpmd>")
         self.session_third.send_expect("start", "testpmd>")
@@ -593,12 +593,12 @@ class TestVEBSwitching(TestCase):
         time.sleep(2)
 
         # PF link down, VF2->VF1
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.target, self.sriov_vfs_port[1].pci), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.dut.testpmd_path, self.sriov_vfs_port[1].pci), "testpmd>", 120)
         self.session_secondary.send_expect("mac_addr add 0 %s" % self.vf1_mac, "testpmd>")
         self.session_secondary.send_expect("set fwd rxonly", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
 
-        self.session_third.send_expect("./%s/app/testpmd -c 0xf00 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test3 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[2].pci, self.vf1_mac), "testpmd>", 120)
+        self.session_third.send_expect("%s -c 0xf00 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test3 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.sriov_vfs_port[2].pci, self.vf1_mac), "testpmd>", 120)
         self.session_third.send_expect("set fwd txonly", "testpmd>")
         self.session_third.send_expect("set promisc all off", "testpmd>")
         
diff --git a/tests/TestSuite_fortville_rss_granularity_config.py b/tests/TestSuite_fortville_rss_granularity_config.py
index 55fec34..8f5aba9 100644
--- a/tests/TestSuite_fortville_rss_granularity_config.py
+++ b/tests/TestSuite_fortville_rss_granularity_config.py
@@ -205,8 +205,8 @@ class TestFortvilleRssGranularityConfig(TestCase):
         # test with different rss queues
         for queue in testQueues:
             self.dut.send_expect(
-                "./%s/app/testpmd  -c fffff -n %d -- -i --coremask=0xffffe --portmask=0x3 --rxq=%d --txq=%d --txqflags=0" %
-                (self.target, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
+                "%s  -c fffff -n %d -- -i --coremask=0xffffe --portmask=0x3 --rxq=%d --txq=%d --txqflags=0" %
+                (self.dut.testpmd_path, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
 
             self.dut.send_expect("set verbose 8", "testpmd> ")
             self.dut.send_expect("set fwd rxonly", "testpmd> ")
@@ -281,8 +281,8 @@ class TestFortvilleRssGranularityConfig(TestCase):
         # test with different rss queues
         for queue in testQueues:
             self.dut.send_expect(
-                "./%s/app/testpmd  -c fffff -n %d -- -i --coremask=0xffffe --portmask=0x3 --rxq=%d --txq=%d --txqflags=0" %
-                (self.target, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
+                "%s  -c fffff -n %d -- -i --coremask=0xffffe --portmask=0x3 --rxq=%d --txq=%d --txqflags=0" %
+                (self.dut.testpmd_path, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
 
             self.dut.send_expect("set verbose 8", "testpmd> ")
             self.dut.send_expect("set fwd rxonly", "testpmd> ")
@@ -358,8 +358,8 @@ class TestFortvilleRssGranularityConfig(TestCase):
         # test with different rss queues
         for queue in testQueues:
             self.dut.send_expect(
-                "./%s/app/testpmd  -c fffff -n %d -- -i --coremask=0xffffe --portmask=0x3 --rxq=%d --txq=%d --txqflags=0" %
-                (self.target, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
+                "%s  -c fffff -n %d -- -i --coremask=0xffffe --portmask=0x3 --rxq=%d --txq=%d --txqflags=0" %
+                (self.dut.testpmd_path, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
 
             self.dut.send_expect("set verbose 8", "testpmd> ")
             self.dut.send_expect("set fwd rxonly", "testpmd> ")
@@ -435,8 +435,8 @@ class TestFortvilleRssGranularityConfig(TestCase):
         # test with different rss queues
         for queue in testQueues:
             self.dut.send_expect(
-                "./%s/app/testpmd  -c fffff -n %d -- -i --coremask=0xffffe --portmask=0x3 --rxq=%d --txq=%d --txqflags=0" %
-                (self.target, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
+                "%s  -c fffff -n %d -- -i --coremask=0xffffe --portmask=0x3 --rxq=%d --txq=%d --txqflags=0" %
+                (self.dut.testpmd_path, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
 
             self.dut.send_expect("set verbose 8", "testpmd> ")
             self.dut.send_expect("set fwd rxonly", "testpmd> ")
@@ -512,8 +512,8 @@ class TestFortvilleRssGranularityConfig(TestCase):
         # test with different rss queues
         for queue in testQueues:
             self.dut.send_expect(
-                "./%s/app/testpmd  -c fffff -n %d -- -i --coremask=0xffffe --portmask=0x3 --rxq=%d --txq=%d --txqflags=0" %
-                (self.target, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
+                "%s  -c fffff -n %d -- -i --coremask=0xffffe --portmask=0x3 --rxq=%d --txq=%d --txqflags=0" %
+                (self.dut.testpmd_path, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
 
             self.dut.send_expect("set verbose 8", "testpmd> ")
             self.dut.send_expect("set fwd rxonly", "testpmd> ")
@@ -573,8 +573,8 @@ class TestFortvilleRssGranularityConfig(TestCase):
         # test with different rss queues
         for queue in testQueues:
             self.dut.send_expect(
-                "./%s/app/testpmd  -c fffff -n %d -- -i --coremask=0xffffe --portmask=0x3 --rxq=%d --txq=%d --txqflags=0" %
-                (self.target, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
+                "%s  -c fffff -n %d -- -i --coremask=0xffffe --portmask=0x3 --rxq=%d --txq=%d --txqflags=0" %
+                (self.dut.testpmd_path, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
 
             self.dut.send_expect("set verbose 8", "testpmd> ")
             self.dut.send_expect("set fwd rxonly", "testpmd> ")
diff --git a/tests/TestSuite_ftag.py b/tests/TestSuite_ftag.py
index d290a04..bbb3714 100644
--- a/tests/TestSuite_ftag.py
+++ b/tests/TestSuite_ftag.py
@@ -117,7 +117,7 @@ class TestFtag(TestCase):
         """
         ftag functional test
         """
-        self.dut.send_expect("./%s/app/testpmd -c f -n 4 -- -i" %self.dut.target,"testpmd", 60)
+        self.dut.send_expect("%s -c f -n 4 -- -i" % self.dut.testpmd_path, "testpmd", 60)
         self.tx_port = self.ports[0]
         self.rx_port = self.ports[1]
 
diff --git a/tests/TestSuite_hotplug.py b/tests/TestSuite_hotplug.py
index 9fa922a..1a26738 100644
--- a/tests/TestSuite_hotplug.py
+++ b/tests/TestSuite_hotplug.py
@@ -85,7 +85,7 @@ class TestPortHotPlug(TestCase):
         """
         first run testpmd after attach port
         """
-        cmd = "./x86_64-native-linuxapp-gcc/app/testpmd -c %s -n %s -- -i" % (self.coremask,self.dut.get_memory_channels())
+        cmd = "%s -c %s -n %s -- -i" % (self.dut.testpmd_path, self.coremask,self.dut.get_memory_channels())
         self.dut.send_expect(cmd,"testpmd>",60)
         session_secondary = self.dut.new_session()
         session_secondary.send_expect("./tools/dpdk-devbind.py --bind=igb_uio %s" % self.dut.ports_info[self.port]['pci'], "#", 60)
@@ -124,7 +124,7 @@ class TestPortHotPlug(TestCase):
         session_secondary = self.dut.new_session()
         session_secondary.send_expect("./usertools/dpdk-devbind.py --bind=igb_uio %s" % self.dut.ports_info[self.port]['pci'], "#", 60)
         self.dut.close_session(session_secondary)
-        cmd = "./x86_64-native-linuxapp-gcc/app/testpmd -c %s -n %s -- -i" % (self.coremask,self.dut.get_memory_channels())
+        cmd = "%s -c %s -n %s -- -i" % (self.dut.testpmd_path, self.coremask,self.dut.get_memory_channels())
         self.dut.send_expect(cmd,"testpmd>",60)
         self.detach(self.port)
         self.attach(self.port)
diff --git a/tests/TestSuite_ipgre.py b/tests/TestSuite_ipgre.py
index 520a974..6fb1822 100644
--- a/tests/TestSuite_ipgre.py
+++ b/tests/TestSuite_ipgre.py
@@ -186,7 +186,7 @@ class TestIpgre(TestCase):
         config_layers =  {'ether': {'src': self.outer_mac_src},
                           'ipv4': {'proto': 'gre'}}
         # Start testpmd and enable rxonly forwarding mode
-        testpmd_cmd = "./%s/app/testpmd -c ffff -n 4 -- -i --enable-rx-cksum --enable-rx-cksum" % self.target
+        testpmd_cmd = "%s -c ffff -n 4 -- -i --enable-rx-cksum --enable-rx-cksum" % self.dut.testpmd_path
         self.dut.send_expect( testpmd_cmd, 
                               "testpmd>", 
                               20)
@@ -225,7 +225,7 @@ class TestIpgre(TestCase):
         }
         
         # Start testpmd and enable rxonly forwarding mode
-        testpmd_cmd = "./%s/app/testpmd -c ffff -n 4 -- -i --enable-rx-cksum" % self.target
+        testpmd_cmd = "%s -c ffff -n 4 -- -i --enable-rx-cksum" % self.dut.testpmd_path
         self.dut.send_expect(testpmd_cmd, "testpmd>", 20)
         self.dut.send_expect("set fwd rxonly", "testpmd>")
         self.dut.send_expect("set verbose 1", "testpmd>")
@@ -263,8 +263,8 @@ class TestIpgre(TestCase):
         inner_mac = "10:00:00:00:00:00"
         
         # Start testpmd with multi queues
-        #testpmd_cmd = "./%s/app/testpmd -c ff -n 3 -- -i  --rxq=4 --txq=4 --txqflags=0x0" % self.target
-        testpmd_cmd = "./%s/app/testpmd -c ff -n 3 -- -i --enable-rx-cksum  --rxq=4 --txq=4" % self.target
+        #testpmd_cmd = "%s -c ff -n 3 -- -i  --rxq=4 --txq=4 --txqflags=0x0" % self.dut.testpmd_path
+        testpmd_cmd = "%s -c ff -n 3 -- -i --enable-rx-cksum  --rxq=4 --txq=4" % self.dut.testpmd_path
         self.dut.send_expect(testpmd_cmd, "testpmd>", 20)
         self.dut.send_expect("set fwd rxonly", "testpmd>")
         self.dut.send_expect("set nbcore 4", "testpmd>")
@@ -307,7 +307,7 @@ class TestIpgre(TestCase):
         Send packet with wrong IP/TCP/UDP/SCTP checksum and check forwarded packet checksum 
         """
         # Start testpmd and enable rxonly forwarding mode
-        testpmd_cmd = "./%s/app/testpmd -c ff -n 3 -- -i --enable-rx-cksum --txqflags=0x0 --port-topology=loop" % self.target
+        testpmd_cmd = "%s -c ff -n 3 -- -i --enable-rx-cksum --txqflags=0x0 --port-topology=loop" % self.dut.testpmd_path
         self.dut.send_expect(testpmd_cmd, "testpmd>", 20)
         self.dut.send_expect("set verbose 1", "testpmd>")
         self.dut.send_expect("set fwd csum", "testpmd>")
diff --git a/tests/TestSuite_kni.py b/tests/TestSuite_kni.py
index 93203f5..1231864 100644
--- a/tests/TestSuite_kni.py
+++ b/tests/TestSuite_kni.py
@@ -293,11 +293,19 @@ class TestKni(TestCase):
         self.verify("in use" not in out, "Error unloading KNI module: " + out)
         if self.drivername == "igb_uio":
             self.dut.send_expect("rmmod igb_uio", "# ", 5)
-            self.dut.send_expect(
-                'insmod ./%s/kmod/igb_uio.ko' % (self.target), "# ", 20)
+            if self.dut.installed_igb_uio == "yes":
+                self.dut.send_expect("modprobe igb_uio", "# ", 20)
+            else:
+                self.dut.send_expect(
+                    'insmod ./%s/kmod/igb_uio.ko' % (self.target), "# ", 20)
+
         self.dut.bind_interfaces_linux()
-        out = self.dut.send_expect(
-            'insmod ./%s/kmod/rte_kni.ko %s' % (self.target, module_param), "# ", 10)
+
+        if self.dut.installed_kni == "yes":
+            out = self.dut.send_expect("modprobe rte_kni %s" % module_param, "# ", 10)
+        else:
+            out = self.dut.send_expect(
+                'insmod ./%s/kmod/rte_kni.ko %s' % (self.target, module_param), "# ", 10)
 
         self.verify("Error" not in out, "Error loading KNI module: " + out)
 
@@ -442,8 +450,11 @@ class TestKni(TestCase):
         self.dut.restore_interfaces()
         allPort = self.dut.ports_info
         if self.drivername in ["igb_uio"]:
-            self.dut.send_expect(
-                "insmod ./" + self.target + "/kmod/igb_uio.ko", "#")
+            if self.dut.installed_igb_uio == "yes":
+                self.dut.send_expect("modprobe igb_uio", "#")
+            else:
+                self.dut.send_expect(
+                    "insmod ./" + self.target + "/kmod/igb_uio.ko", "#")
         for port in range(0, len(allPort)):
             if port in dut_ports:
                 white_list.append(allPort[port]['pci'])
diff --git a/tests/TestSuite_link_status_interrupt.py b/tests/TestSuite_link_status_interrupt.py
index ae205cc..5d1a9ef 100644
--- a/tests/TestSuite_link_status_interrupt.py
+++ b/tests/TestSuite_link_status_interrupt.py
@@ -88,8 +88,12 @@ class TestLinkStatusInterrupt(TestCase):
                 self.coremask, self.dut.get_memory_channels(), self.portmask)
             for mode in ["legacy", "msix"]:
                 self.dut.send_expect("rmmod -f igb_uio", "#", 20)
-                self.dut.send_expect(
-                    'insmod %s/kmod/igb_uio.ko "intr_mode=%s"' % (self.target, mode), "# ")
+                if self.dut.installed_igb_uio == "yes":
+                    self.dut.send_expect(
+                        'modprobe igb_uio "intr_mode=%s"' % mode, "# ")
+                else:
+                    self.dut.send_expect(
+                        'insmod %s/kmod/igb_uio.ko "intr_mode=%s"' % (self.target, mode), "# ")
                 self.dut.bind_interfaces_linux()
                 self.dut.send_expect(cmdline, "Aggregate statistics", 60)
                 self.set_link_status_and_verify(self.dut_ports[0], 'Down')
@@ -114,8 +118,12 @@ class TestLinkStatusInterrupt(TestCase):
                 self.coremask, self.dut.get_memory_channels(), self.portmask)
             for mode in ["legacy", "msix"]:
                 self.dut.send_expect("rmmod -f igb_uio", "#", 20)
-                self.dut.send_expect(
-                    'insmod %s/kmod/igb_uio.ko "intr_mode=%s"' % (self.target, mode), "# ")
+                if self.dut.installed_igb_uio == "yes":
+                    self.dut.send_expect(
+                        'modprobe igb_uio "intr_mode=%s"' % mode, "# ")
+                else:
+                    self.dut.send_expect(
+                        'insmod %s/kmod/igb_uio.ko "intr_mode=%s"' % (self.target, mode), "# ")
                 self.dut.bind_interfaces_linux()
                 self.dut.send_expect(cmdline, "Aggregate statistics", 60)
                 for port in self.dut_ports:
diff --git a/tests/TestSuite_nvgre.py b/tests/TestSuite_nvgre.py
index 6b838b4..3eea967 100644
--- a/tests/TestSuite_nvgre.py
+++ b/tests/TestSuite_nvgre.py
@@ -438,8 +438,8 @@ class TestNvgre(TestCase):
         """
         send nvgre packet and check whether testpmd detect the correct packet type
         """
-        out = self.dut.send_expect("./%s/app/testpmd -c %s -n %d -- -i --disable-rss --rxq=4 --txq=4 --nb-cores=4 --portmask=%s --txqflags=0"
-                                   % (self.target, self.coremask, self.dut.get_memory_channels(), self.portmask), "testpmd>", 30)
+        out = self.dut.send_expect("%s -c %s -n %d -- -i --disable-rss --rxq=4 --txq=4 --nb-cores=4 --portmask=%s --txqflags=0"
+                                   % (self.dut.testpmd_path, self.coremask, self.dut.get_memory_channels(), self.portmask), "testpmd>", 30)
         out = self.dut.send_expect("set fwd rxonly", "testpmd>", 10)
         self.dut.send_expect("set verbose 1", "testpmd>", 10)
 
@@ -467,8 +467,8 @@ class TestNvgre(TestCase):
         """
         send nvgre packet and check whether receive packet in assigned queue
         """
-        self.dut.send_expect("./%s/app/testpmd -c %s -n %d -- -i --disable-rss --rxq=4 --txq=4 --nb-cores=4 --portmask=%s --txqflags=0"
-                             % (self.target, self.coremask, self.dut.get_memory_channels(), self.portmask), "testpmd>", 30)
+        self.dut.send_expect("%s -c %s -n %d -- -i --disable-rss --rxq=4 --txq=4 --nb-cores=4 --portmask=%s --txqflags=0"
+                             % (self.dut.testpmd_path, self.coremask, self.dut.get_memory_channels(), self.portmask), "testpmd>", 30)
         self.dut.send_expect("set fwd rxonly", "testpmd>", 10)
         self.dut.send_expect("set verbose 1", "testpmd>", 10)
 
@@ -543,8 +543,8 @@ class TestNvgre(TestCase):
         self.logger.info("chksums_ref:" + str(chksums_default))
 
         # start testpmd with 2queue/1port
-        out = self.dut.send_expect("./%s/app/testpmd -c %s -n %d -- -i --disable-rss --rxq=4 --txq=4 --nb-cores=4 --portmask=%s --enable-rx-cksum --txqflags=0"
-                                   % (self.target, self.coremask, self.dut.get_memory_channels(), self.portmask), "testpmd>", 30)
+        out = self.dut.send_expect("%s -c %s -n %d -- -i --disable-rss --rxq=4 --txq=4 --nb-cores=4 --portmask=%s --enable-rx-cksum --txqflags=0"
+                                   % (self.dut.testpmd_path, self.coremask, self.dut.get_memory_channels(), self.portmask), "testpmd>", 30)
         # disable vlan filter
         self.dut.send_expect('vlan set filter off %d' % self.dut_rx_port, "testpmd")
 
@@ -664,8 +664,8 @@ class TestNvgre(TestCase):
         self.nvgre_filter(filter_type="imac", remove=True)
         config = NvgreTestConfig(self)
         # config.outer_mac_dst = self.dut_port_mac
-        self.dut.send_expect("./%s/app/testpmd -c %s -n %d -- -i --disable-rss --rxq=4 --txq=4 --nb-cores=4 --portmask=%s --txqflags=0"
-                             % (self.target, self.coremask, self.dut.get_memory_channels(), self.portmask), "testpmd>", 30)
+        self.dut.send_expect("%s -c %s -n %d -- -i --disable-rss --rxq=4 --txq=4 --nb-cores=4 --portmask=%s --txqflags=0"
+                             % (self.dut.testpmd_path, self.coremask, self.dut.get_memory_channels(), self.portmask), "testpmd>", 30)
         out = self.dut.send_expect("tunnel_filter add %d %s %s %s %d nvgre %s %d %d"
                                    % (self.dut_rx_port, config.outer_mac_dst, self.invalid_mac, config.inner_ip_dst, vlan_id,
                                       filter_type, config.tni, queue_id), "testpmd>", 10)
@@ -727,7 +727,7 @@ class TestNvgre(TestCase):
         core_list = self.dut.get_core_list('1S/%dC/1T' % (self.tunnel_multiqueue * 2), socket=self.ports_socket)
         core_mask = utils.create_mask(core_list)
 
-        command_line = "./%s/app/testpmd -c %s -n %d -- -i --disable-rss --coremask=%s --rxq=4 --txq=4 --portmask=%s" % (self.target,
+        command_line = "%s -c %s -n %d -- -i --disable-rss --coremask=%s --rxq=4 --txq=4 --portmask=%s" % (self.dut.testpmd_path,
                                                                                                                          self.all_cores_mask,
                                                                                                                          self.dut.get_memory_channels(),
                                                                                                                          core_mask, self.portmask)
@@ -844,8 +844,8 @@ class TestNvgre(TestCase):
 
             core_mask = utils.create_mask(core_list)
 
-            command_line = "./%s/app/testpmd -c %s -n %d -- -i \
- --disable-rss --coremask=%s --portmask=%s" % (self.target,
+            command_line = "%s -c %s -n %d -- -i \
+ --disable-rss --coremask=%s --portmask=%s" % (self.dut.testpmd_path,
                                                all_cores_mask,
                                                self.dut.get_memory_channels(),
                                                core_mask, self.portmask)
diff --git a/tests/TestSuite_pmdpcap.py b/tests/TestSuite_pmdpcap.py
index 843a498..4c9a28a 100644
--- a/tests/TestSuite_pmdpcap.py
+++ b/tests/TestSuite_pmdpcap.py
@@ -124,13 +124,13 @@ class TestPmdPcap(TestCase):
         self.create_pcap_file(in_pcap, TestPmdPcap.pcap_file_sizes[0])
         self.dut.session.copy_file_to(in_pcap)
 
-        command = ("./{}/app/testpmd -c {} -n {} " +
+        command = ("{} -c {} -n {} " +
                    "--vdev=eth_pcap0,rx_pcap={},tx_pcap={} " +
                    "-- -i --port-topology=chained --no-flush-rx")
         if "cavium" in self.dut.nic_type:
             command += " --disable-hw-vlan-filter"
 
-        self.dut.send_expect(command.format(self.target, core_mask,
+        self.dut.send_expect(command.format(self.dut.testpmd_path, core_mask,
                              self.memory_channel,
                              TestPmdPcap.dut_pcap_files_path + in_pcap,
                              out_pcap), 'testpmd> ', 15)
@@ -159,14 +159,14 @@ class TestPmdPcap(TestCase):
         self.create_pcap_file(in_pcap2, TestPmdPcap.pcap_file_sizes[1])
         self.dut.session.copy_file_to(in_pcap2)
 
-        command = ("./{}/app/testpmd -c {} -n {} " +
+        command = ("{} -c {} -n {} " +
                    "--vdev=eth_pcap0,rx_pcap={},tx_pcap={} " +
                    "--vdev=eth_pcap1,rx_pcap={},tx_pcap={} " +
                    "-- -i --no-flush-rx")
         if "cavium" in self.dut.nic_type:
             command += " --disable-hw-vlan-filter"
 
-        self.dut.send_expect(command.format(self.target, core_mask,
+        self.dut.send_expect(command.format(self.dut.testpmd_path, core_mask,
                                             self.memory_channel,
                                             TestPmdPcap.dut_pcap_files_path +
                                             in_pcap1,
diff --git a/tests/TestSuite_pmdrss_hash.py b/tests/TestSuite_pmdrss_hash.py
index 83bac40..dc339c1 100644
--- a/tests/TestSuite_pmdrss_hash.py
+++ b/tests/TestSuite_pmdrss_hash.py
@@ -462,8 +462,8 @@ class TestPmdrssHash(TestCase):
         # test with different rss queues
         for queue in testQueues:
             self.dut.send_expect(
-                "./%s/app/testpmd  -c fffff -n %d -- -i --coremask=0xffffe --rxq=%d --txq=%d" %
-                (self.target, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
+                "%s  -c fffff -n %d -- -i --coremask=0xffffe --rxq=%d --txq=%d" %
+                (self.dut.testpmd_path, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
 
             for iptype, rsstype in iptypes.items():
                 self.dut.send_expect("set verbose 8", "testpmd> ")
@@ -513,8 +513,8 @@ class TestPmdrssHash(TestCase):
         # test with different rss queues
         for queue in testQueues:
             self.dut.send_expect(
-                "./%s/app/testpmd  -c fffff -n %d -- -i --coremask=0xffffe --rxq=%d --txq=%d" %
-                (self.target, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
+                "%s  -c fffff -n %d -- -i --coremask=0xffffe --rxq=%d --txq=%d" %
+                (self.dut.testpmd_path, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
 
             for iptype, rsstype in iptypes.items():
                 self.dut.send_expect("set verbose 8", "testpmd> ")
@@ -569,8 +569,8 @@ class TestPmdrssHash(TestCase):
         # test with different rss queues
         for queue in testQueues:
             self.dut.send_expect(
-                "./%s/app/testpmd  -c fffff -n %d -- -i --coremask=0xffffe --rxq=%d --txq=%d" %
-                (self.target, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
+                "%s  -c fffff -n %d -- -i --coremask=0xffffe --rxq=%d --txq=%d" %
+                (self.dut.testpmd_path, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
 
             for iptype, rsstype in iptypes.items():
                 self.logger.info("***********************%s rss test********************************" % iptype)
@@ -622,8 +622,8 @@ class TestPmdrssHash(TestCase):
         # test with different rss queues
         for queue in testQueues:
             self.dut.send_expect(
-                "./%s/app/testpmd  -c fffff -n %d -- -i --coremask=0xffffe --rxq=%d --txq=%d" %
-                (self.target, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
+                "%s  -c fffff -n %d -- -i --coremask=0xffffe --rxq=%d --txq=%d" %
+                (self.dut.testpmd_path, self.dut.get_memory_channels(), queue, queue), "testpmd> ", 120)
 
             for iptype, rsstype in iptypes.items():
                 self.dut.send_expect("set verbose 8", "testpmd> ")
@@ -655,7 +655,7 @@ class TestPmdrssHash(TestCase):
     def test_dynamic_rss_bond_config(self):
         
         # setup testpmd and finish bond config
-        self.dut.send_expect("./%s/app/testpmd -c f -n 4 -- -i --txqflags=0" % self.target, "testpmd> ", 120)
+        self.dut.send_expect("%s -c f -n 4 -- -i --txqflags=0" % self.dut.testpmd_path, "testpmd> ", 120)
         out = self.dut.send_expect("create bonded device 3 0", "testpmd> ", 30)
         bond_device_id = int(re.search("port \d+", out).group().split(" ")[-1].strip())
 
diff --git a/tests/TestSuite_pmdrssreta.py b/tests/TestSuite_pmdrssreta.py
index 10af47f..2cafd08 100644
--- a/tests/TestSuite_pmdrssreta.py
+++ b/tests/TestSuite_pmdrssreta.py
@@ -235,7 +235,7 @@ class TestPmdrssreta(TestCase):
         localPort = self.tester.get_local_port(dutPorts[0])
         itf = self.tester.get_interface(localPort)
         self.dut.kill_all()
-        self.dut.send_expect("./%s/app/testpmd  -c fffff -n %d -- -i --coremask=0xffffe --rxq=2 --txq=2" % (self.target, self.dut.get_memory_channels()), "testpmd> ", 120)
+        self.dut.send_expect("%s  -c fffff -n %d -- -i --coremask=0xffffe --rxq=2 --txq=2" % (self.dut.testpmd_path, self.dut.get_memory_channels()), "testpmd> ", 120)
         self.dut.send_expect("start", "testpmd> ", 120)
         out = self.dut.send_expect("show port info all", "testpmd> ", 120)
         self.dut.send_expect("quit", "# ", 30)
diff --git a/tests/TestSuite_qinq_filter.py b/tests/TestSuite_qinq_filter.py
index a6787ca..25befbe 100644
--- a/tests/TestSuite_qinq_filter.py
+++ b/tests/TestSuite_qinq_filter.py
@@ -145,9 +145,9 @@ class TestQinqFilter(TestCase):
         Enable receipt of dual VLAN packets
         """
         
-        self.dut.send_expect(r'./%s/app/testpmd -c %s -n 4 -- -i \
+        self.dut.send_expect(r'%s -c %s -n 4 -- -i \
                                --portmask=%s --port-topology=loop \
-                               --rxq=4 --txq=4 --txqflags=0x0  --disable-rss' % (self.target, self.coreMask, self.portMask),
+                               --rxq=4 --txq=4 --txqflags=0x0  --disable-rss' % (self.dut.testpmd_path, self.coreMask, self.portMask),
                                "testpmd> ")
         self.dut.send_expect("vlan set qinq on %s" % dutRxPortId, "testpmd> ")
         self.dut.send_expect("set fwd rxonly", "testpmd> ")
@@ -165,9 +165,9 @@ class TestQinqFilter(TestCase):
         """
         qinq filter packet received by assign PF queues
         """
-        self.dut.send_expect(r'./%s/app/testpmd -c %s -n 4 -- -i \
+        self.dut.send_expect(r'%s -c %s -n 4 -- -i \
                                --portmask=%s --port-topology=loop \
-                               --rxq=4 --txq=4 --txqflags=0x0  --disable-rss' % (self.target, self.coreMask, self.portMask),
+                               --rxq=4 --txq=4 --txqflags=0x0  --disable-rss' % (self.dut.testpmd_path, self.coreMask, self.portMask),
                                "testpmd> ")
         self.dut.send_expect("vlan set qinq on %s" % dutRxPortId, "testpmd> ")
         self.dut.send_expect("set fwd rxonly", "testpmd> ")
@@ -201,10 +201,10 @@ class TestQinqFilter(TestCase):
         vf0_session = self.dut.new_session('qinq_filter')
         vf1_session = self.dut.new_session('qinq_filter')
 
-        self.dut.send_expect(r'./%s/app/testpmd -c %s -n 4  \
+        self.dut.send_expect(r'%s -c %s -n 4  \
                                --socket-mem=1024,1024 --file-prefix=pf -w %s -- -i --port-topology=loop \
                                --rxq=4 --txq=4 --txqflags=0x0  --disable-rss' 
-                               % (self.target, self.coreMask, self.dut.ports_info[dutRxPortId]['pci']),
+                               % (self.dut.testpmd_path, self.coreMask, self.dut.ports_info[dutRxPortId]['pci']),
                                "testpmd> ")
         self.dut.send_expect("vlan set qinq on %s" % dutRxPortId, "testpmd> ")
         self.dut.send_expect("set fwd rxonly", "testpmd> ")
@@ -218,16 +218,16 @@ class TestQinqFilter(TestCase):
         # out vlan 3, inner vlan 4094 packet will received by pf queue 1
         self.dut.send_expect(r'flow create 0 ingress pattern eth / vlan tci is 3 / vlan tci is 4094 / end actions pf / queue index 1 / end', "testpmd> ")
 
-        vf0_session.send_expect(r'./%s/app/testpmd -c %s -n 4  \
+        vf0_session.send_expect(r'%s -c %s -n 4  \
                                --socket-mem=1024,1024 --file-prefix=vf0 -w %s -- -i --port-topology=loop \
                                --rxq=4 --txq=4 --txqflags=0x0  --disable-rss' 
-                               % (self.target, self.coreMask, vf_list[0]),
+                               % (self.dut.testpmd_path, self.coreMask, vf_list[0]),
                                "testpmd> ")
                                                               
-        vf1_session.send_expect(r'./%s/app/testpmd -c %s -n 4 \
+        vf1_session.send_expect(r'%s -c %s -n 4 \
                                --socket-mem=1024,1024 --file-prefix=vf1 -w %s -- -i --port-topology=loop \
                                --rxq=4 --txq=4 --txqflags=0x0  --disable-rss' 
-                               % (self.target, self.coreMask, vf_list[1]),
+                               % (self.dut.testpmd_path, self.coreMask, vf_list[1]),
                                "testpmd>") 
         for session_name in [vf0_session, vf1_session]:
             session_name.send_expect("set fwd rxonly", "testpmd> ")
@@ -270,10 +270,10 @@ class TestQinqFilter(TestCase):
         vf0_session = self.dut.new_session('qinq_filter')
         vf1_session = self.dut.new_session('qinq_filter')
 
-        self.dut.send_expect(r'./%s/app/testpmd -c %s -n 4 \
+        self.dut.send_expect(r'%s -c %s -n 4 \
                                --socket-mem=1024,1024 --file-prefix=pf -w %s -- -i --port-topology=loop \
                                --rxq=4 --txq=4 --txqflags=0x0  --disable-rss' 
-                               % (self.target, self.coreMask, self.dut.ports_info[dutRxPortId]['pci']),
+                               % (self.dut.testpmd_path, self.coreMask, self.dut.ports_info[dutRxPortId]['pci']),
                                "testpmd> ")
         self.dut.send_expect("vlan set qinq on %s" % dutRxPortId, "testpmd> ")
         self.dut.send_expect("set fwd rxonly", "testpmd> ")
@@ -290,16 +290,16 @@ class TestQinqFilter(TestCase):
                                
         self.dut.send_expect('vlan set outer tpid 0x88a8 0', "testpmd")
         
-        vf0_session.send_expect(r'./%s/app/testpmd -c %s -n 4 \
+        vf0_session.send_expect(r'%s -c %s -n 4 \
                                --socket-mem=1024,1024 --file-prefix=vf0 -w %s -- -i --port-topology=loop \
                                --rxq=4 --txq=4 --txqflags=0x0  --disable-rss' 
-                               % (self.target, self.coreMask, vf_list[0]),
+                               % (self.dut.testpmd_path, self.coreMask, vf_list[0]),
                                "testpmd> ")
                                                               
-        vf1_session.send_expect(r'./%s/app/testpmd -c %s -n 4 \
+        vf1_session.send_expect(r'%s -c %s -n 4 \
                                --socket-mem=1024,1024 --file-prefix=vf1 -w %s -- -i --port-topology=loop \
                                --rxq=4 --txq=4 --txqflags=0x0  --disable-rss' 
-                               % (self.target, self.coreMask, vf_list[1]),
+                               % (self.dut.testpmd_path, self.coreMask, vf_list[1]),
                                "testpmd>") 
         for session_name in [vf0_session, vf1_session]:
             session_name.send_expect("set fwd rxonly", "testpmd> ")
diff --git a/tests/TestSuite_short_live.py b/tests/TestSuite_short_live.py
index d153975..2c0b23d 100644
--- a/tests/TestSuite_short_live.py
+++ b/tests/TestSuite_short_live.py
@@ -125,7 +125,7 @@ class TestShortLiveApp(TestCase):
         Basic rx/tx forwarding test
         """
         #dpdk start
-        self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 -- -i --portmask=0x3" % self.target, "testpmd>", 120)
+        self.dut.send_expect("%s -c 0xf -n 4 -- -i --portmask=0x3" % self.dut.testpmd_path, "testpmd>", 120)
         time.sleep(5)
         self.dut.send_expect("set fwd mac", "testpmd>")
         self.dut.send_expect("set promisc all off", "testpmd>")
@@ -138,7 +138,7 @@ class TestShortLiveApp(TestCase):
         """
         time = []
         regex = re.compile(".* (\d+:\d{2}\.\d{2}).*")
-        out = self.dut.send_expect("echo quit | time ./%s/app/testpmd -c 0x3 -n 4 --no-pci -- -i" % self.target, "#", 120)
+        out = self.dut.send_expect("echo quit | time %s -c 0x3 -n 4 --no-pci -- -i" % self.dut.testpmd_path, "#", 120)
         time = regex.findall(out)
 
         if time != []:
@@ -151,7 +151,7 @@ class TestShortLiveApp(TestCase):
         for i in range(repeat_time):
             #dpdk start
             print "clean_up_with_signal_testpmd round %d" % (i + 1)
-            self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 -- -i --portmask=0x3" % self.target, "LSC event", 120)
+            self.dut.send_expect("%s -c 0xf -n 4 -- -i --portmask=0x3" % self.dut.testpmd_path, "LSC event", 120)
             self.dut.send_expect("set fwd mac", "testpmd>")
             self.dut.send_expect("set promisc all off", "testpmd>")
             self.dut.send_expect("start", "testpmd>")
diff --git a/tests/TestSuite_tso.py b/tests/TestSuite_tso.py
index 0689291..ab9aa23 100644
--- a/tests/TestSuite_tso.py
+++ b/tests/TestSuite_tso.py
@@ -157,7 +157,7 @@ class TestTSO(TestCase):
         self.tester.send_expect("ethtool -K %s rx off tx off tso off gso off gro off lro off" % tx_interface, "# ")
         self.tester.send_expect("ip l set %s up" % tx_interface, "# ")
 
-        cmd = "./%s/app/testpmd -c %s -n %d %s -- -i --rxd=512 --txd=512 --burst=32 --rxfreet=64 --mbcache=128 --portmask=%s --txpt=36 --txht=0 --txwt=0 --txfreet=32 --txrst=32 --txqflags=0 " % (self.target, self.coreMask, self.dut.get_memory_channels(), self.blacklist, self.portMask)
+        cmd = "%s -c %s -n %d %s -- -i --rxd=512 --txd=512 --burst=32 --rxfreet=64 --mbcache=128 --portmask=%s --txpt=36 --txht=0 --txwt=0 --txfreet=32 --txrst=32 --txqflags=0 " % (self.dut.testpmd_path, self.coreMask, self.dut.get_memory_channels(), self.blacklist, self.portMask)
         self.dut.send_expect(cmd, "testpmd> ", 120)
         self.dut.send_expect("set verbose 1", "testpmd> ", 120)
         self.dut.send_expect("csum set ip hw %d" % self.dut_ports[0], "testpmd> ", 120)
@@ -223,7 +223,7 @@ class TestTSO(TestCase):
         self.tester.send_expect("ethtool -K %s rx off tx off tso off gso off gro off lro off" % tx_interface, "# ")
         self.tester.send_expect("ip l set %s up" % tx_interface, "# ")
 
-        cmd = "./%s/app/testpmd -c %s -n %d %s -- -i --rxd=512 --txd=512 --burst=32 --rxfreet=64 --mbcache=128 --portmask=%s --txpt=36 --txht=0 --txwt=0 --txfreet=32 --txrst=32 --txqflags=0 " % (self.target, self.coreMask, self.dut.get_memory_channels(), self.blacklist, self.portMask)
+        cmd = "%s -c %s -n %d %s -- -i --rxd=512 --txd=512 --burst=32 --rxfreet=64 --mbcache=128 --portmask=%s --txpt=36 --txht=0 --txwt=0 --txfreet=32 --txrst=32 --txqflags=0 " % (self.dut.testpmd_path, self.coreMask, self.dut.get_memory_channels(), self.blacklist, self.portMask)
         self.dut.send_expect(cmd, "testpmd> ", 120)
         self.dut.send_expect("set verbose 1", "testpmd> ", 120)
         self.dut.send_expect("csum set ip hw %d" % self.dut_ports[0], "testpmd> ", 120)
@@ -287,7 +287,7 @@ class TestTSO(TestCase):
             else:
                 queues = 1
 
-            command_line = "./%s/app/testpmd -c %s -n %d %s -- -i --coremask=%s --rxd=512 --txd=512 --burst=32 --rxfreet=64 --mbcache=128 --portmask=%s --txpt=36 --txht=0 --txwt=0 --txfreet=32 --txrst=32 --txqflags=0 " % (self.target, self.all_cores_mask, self.dut.get_memory_channels(), self.blacklist, self.coreMask, self.portMask)
+            command_line = "%s -c %s -n %d %s -- -i --coremask=%s --rxd=512 --txd=512 --burst=32 --rxfreet=64 --mbcache=128 --portmask=%s --txpt=36 --txht=0 --txwt=0 --txfreet=32 --txrst=32 --txqflags=0 " % (self.dut.testpmd_path, self.all_cores_mask, self.dut.get_memory_channels(), self.blacklist, self.coreMask, self.portMask)
 
             info = "Executing PMD using %s\n" % test_cycle['cores']
             self.logger.info(info)
diff --git a/tests/TestSuite_uni_pkt.py b/tests/TestSuite_uni_pkt.py
index 6975f2d..78f9f7f 100644
--- a/tests/TestSuite_uni_pkt.py
+++ b/tests/TestSuite_uni_pkt.py
@@ -64,7 +64,7 @@ class TestUniPacket(TestCase):
         tester_port = self.tester.get_local_port(self.dut_port)
         self.tester_iface = self.tester.get_interface(tester_port)
         self.dut.send_expect(
-            "./%s/app/testpmd -c f -n 4 -- -i --txqflags=0x0" % self.target, "testpmd>", 20)
+            "%s -c f -n 4 -- -i --txqflags=0x0" % self.dut.testpmd_path, "testpmd>", 20)
         self.dut.send_expect("set fwd rxonly", "testpmd>")
         self.dut.send_expect("set verbose 1", "testpmd>")
         self.dut.send_expect("start", "testpmd>")
diff --git a/tests/TestSuite_unit_tests_dump.py b/tests/TestSuite_unit_tests_dump.py
index 90588cb..329cc37 100644
--- a/tests/TestSuite_unit_tests_dump.py
+++ b/tests/TestSuite_unit_tests_dump.py
@@ -85,7 +85,7 @@ class TestUnitTestsDump(TestCase):
         """
         Run history log dump test case.
         """
-        self.dut.send_expect("./%s/app/testpmd -n 1 -c f -- -i" % (self.target), "testpmd>", self.start_test_time)
+        self.dut.send_expect("%s -n 1 -c f -- -i" % (self.dut.testpmd_path), "testpmd>", self.start_test_time)
         out = self.dut.send_expect("dump_ring", "testpmd>", self.run_cmd_time)
         self.dut.send_expect("quit", "# ")
         match_regex = "ring <(.*?)>"
@@ -100,7 +100,7 @@ class TestUnitTestsDump(TestCase):
         """
         Run mempool dump test case.
         """
-        self.dut.send_expect("./%s/app/testpmd -n 1 -c f -- -i" % (self.target), "testpmd>", self.start_test_time)
+        self.dut.send_expect("%s -n 1 -c f -- -i" % (self.dut.testpmd_path), "testpmd>", self.start_test_time)
         out = self.dut.send_expect("dump_mempool", "testpmd>", self.run_cmd_time * 2)
         self.dut.send_expect("quit", "# ")
         match_regex = "mempool <(.*?)>@0x(.*?)\r\n"
@@ -133,7 +133,7 @@ class TestUnitTestsDump(TestCase):
         """
         Run memzone dump test case.
         """
-        self.dut.send_expect("./%s/app/testpmd -n 1 -c f -- -i" % (self.target), "testpmd>", self.start_test_time)
+        self.dut.send_expect("%s -n 1 -c f -- -i" % (self.dut.testpmd_path), "testpmd>", self.start_test_time)
         out = self.dut.send_expect("dump_memzone", "testpmd>", self.run_cmd_time * 2)
         self.dut.send_expect("quit", "# ")
 
diff --git a/tests/TestSuite_unit_tests_kni.py b/tests/TestSuite_unit_tests_kni.py
index ea8ef79..d6d5d0f 100644
--- a/tests/TestSuite_unit_tests_kni.py
+++ b/tests/TestSuite_unit_tests_kni.py
@@ -57,7 +57,10 @@ class TestUnitTestsKni(TestCase):
         if "rte_kni" in out:
             self.dut.send_expect('rmmod rte_kni.ko', "# ")
 
-        out = self.dut.send_expect('insmod ./%s/kmod/rte_kni.ko lo_mode=lo_mode_fifo' % (self.target), "# ")
+        if self.dut.installed_kni == "yes":
+            out = self.dut.send_expect('modprobe rte_kni lo_mode=lo_mode_fifo', "# ")
+        else:
+            out = self.dut.send_expect('insmod ./%s/kmod/rte_kni.ko lo_mode=lo_mode_fifo' % (self.target), "# ")
 
         self.verify("Error" not in out, "Error loading KNI module: " + out)
 
diff --git a/tests/TestSuite_veb_switch.py b/tests/TestSuite_veb_switch.py
index 01a5366..75f395b 100644
--- a/tests/TestSuite_veb_switch.py
+++ b/tests/TestSuite_veb_switch.py
@@ -213,11 +213,11 @@ class TestVEBSwitching(TestCase):
         the packets. Check Inter VF-VF MAC switch.
     """
         self.setup_env(driver='default')
-        self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[0].pci, self.vf1_mac), "testpmd>", 120)
+        self.dut.send_expect("%s -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.sriov_vfs_port[0].pci, self.vf1_mac), "testpmd>", 120)
         self.dut.send_expect("set fwd txonly", "testpmd>")
         self.dut.send_expect("set promisc all off", "testpmd>")
 
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.target, self.sriov_vfs_port[1].pci), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.dut.testpmd_path, self.sriov_vfs_port[1].pci), "testpmd>", 120)
         self.session_secondary.send_expect("set fwd rxonly", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
         self.session_secondary.send_expect("start", "testpmd>", 5)
@@ -239,12 +239,12 @@ class TestVEBSwitching(TestCase):
         the packets. Check Inter VF-VF MAC switch.
         """
         self.setup_env(driver='default')
-        self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[0].pci, self.vf1_mac), "testpmd>", 120)
+        self.dut.send_expect("%s -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.sriov_vfs_port[0].pci, self.vf1_mac), "testpmd>", 120)
         self.dut.send_expect("set fwd mac", "testpmd>")
         self.dut.send_expect("set promisc all off", "testpmd>")
         self.dut.send_expect("start", "testpmd>")
         time.sleep(2)
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.target, self.sriov_vfs_port[1].pci), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.dut.testpmd_path, self.sriov_vfs_port[1].pci), "testpmd>", 120)
         self.session_secondary.send_expect("set fwd rxonly", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
         self.session_secondary.send_expect("start", "testpmd>")
@@ -272,12 +272,12 @@ class TestVEBSwitching(TestCase):
         # the two vfs belongs to different vlans
         self.dut.send_expect("ip link set %s vf 0 vlan 1" % self.pf_interface, "# ", 1)
         self.dut.send_expect("ip link set %s vf 1 vlan 2" % self.pf_interface, "# ", 1)
-        self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[0].pci, self.vf1_mac), "testpmd>", 120)
+        self.dut.send_expect("%s -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.sriov_vfs_port[0].pci, self.vf1_mac), "testpmd>", 120)
         self.dut.send_expect("set fwd mac", "testpmd>")
         self.dut.send_expect("set promisc all off", "testpmd>")
         self.dut.send_expect("start", "testpmd>")
         time.sleep(2)
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.target, self.sriov_vfs_port[1].pci), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.dut.testpmd_path, self.sriov_vfs_port[1].pci), "testpmd>", 120)
         self.session_secondary.send_expect("set fwd mac", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
         self.session_secondary.send_expect("start", "testpmd>")
@@ -299,12 +299,12 @@ class TestVEBSwitching(TestCase):
     
         # the two vfs belongs to the same vlan
         self.dut.send_expect("ip link set %s vf 1 vlan 1" % self.pf_interface, "# ", 1)
-        self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[0].pci, self.vf1_mac), "testpmd>", 120)
+        self.dut.send_expect("%s -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.sriov_vfs_port[0].pci, self.vf1_mac), "testpmd>", 120)
         self.dut.send_expect("set fwd mac", "testpmd>")
         self.dut.send_expect("set promisc all off", "testpmd>")
         self.dut.send_expect("start", "testpmd>")
         time.sleep(2)
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.target, self.sriov_vfs_port[1].pci), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.dut.testpmd_path, self.sriov_vfs_port[1].pci), "testpmd>", 120)
         self.session_secondary.send_expect("set fwd mac", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
         self.session_secondary.send_expect("start", "testpmd>")
@@ -329,12 +329,12 @@ class TestVEBSwitching(TestCase):
         """
         # VF->PF
         self.setup_env(driver=self.drivername)
-        self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i" % (self.target, self.pf_pci), "testpmd>", 120)
+        self.dut.send_expect("%s -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i" % (self.dut.testpmd_path, self.pf_pci), "testpmd>", 120)
         self.dut.send_expect("set fwd rxonly", "testpmd>")
         self.dut.send_expect("set promisc all off", "testpmd>")
         self.dut.send_expect("start", "testpmd>")
         time.sleep(2)
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[0].pci, self.pf_mac_address), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.sriov_vfs_port[0].pci, self.pf_mac_address), "testpmd>", 120)
         self.session_secondary.send_expect("set fwd txonly", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
         self.session_secondary.send_expect("start", "testpmd>")
@@ -354,11 +354,11 @@ class TestVEBSwitching(TestCase):
         time.sleep(2)
  
         #PF->VF
-        self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i --eth-peer=0,%s" % (self.target, self.pf_pci, self.vf0_mac), "testpmd>", 120)
+        self.dut.send_expect("%s -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.pf_pci, self.vf0_mac), "testpmd>", 120)
         self.dut.send_expect("set fwd txonly", "testpmd>")
         self.dut.send_expect("set promisc all off", "testpmd>")
         
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.target, self.sriov_vfs_port[0].pci), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.dut.testpmd_path, self.sriov_vfs_port[0].pci), "testpmd>", 120)
         self.session_secondary.send_expect("mac_addr add 0 %s" % self.vf0_mac, "testpmd>")
         self.session_secondary.send_expect("set fwd rxonly", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
@@ -381,13 +381,13 @@ class TestVEBSwitching(TestCase):
         time.sleep(2)
 
         # tester->VF
-        self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i" % (self.target, self.pf_pci), "testpmd>", 120)
+        self.dut.send_expect("%s -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i" % (self.dut.testpmd_path, self.pf_pci), "testpmd>", 120)
         self.dut.send_expect("set fwd mac", "testpmd>")
         self.dut.send_expect("set promisc all off", "testpmd>")
         self.dut.send_expect("start", "testpmd>")
         time.sleep(2)
 
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.target, self.sriov_vfs_port[0].pci), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.dut.testpmd_path, self.sriov_vfs_port[0].pci), "testpmd>", 120)
         self.session_secondary.send_expect("mac_addr add 0 %s" % self.vf0_mac, "testpmd>")
         self.session_secondary.send_expect("set fwd rxonly", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
@@ -423,15 +423,15 @@ class TestVEBSwitching(TestCase):
         time.sleep(2)
 
         # VF1->VF2
-        self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i" % (self.target, self.pf_pci), "testpmd>", 120)
+        self.dut.send_expect("%s -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i" % (self.dut.testpmd_path, self.pf_pci), "testpmd>", 120)
         self.dut.send_expect("set promisc all off", "testpmd>")
 
-        self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[0].pci, self.vf1_mac), "testpmd>", 120)
+        self.session_secondary.send_expect("%s -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.dut.testpmd_path, self.sriov_vfs_port[0].pci, self.vf1_mac), "testpmd>", 120)
         self.session_secondary.send_expect("set fwd txonly", "testpmd>")
         self.session_secondary.send_expect("set promisc all off", "testpmd>")
         time.sleep(2)
 
-        self.session_third.send_expect("./%s/app/testpmd -c 0xf00 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test3 -- -i" % (self.target, self.sriov_vfs_port[1].pci), "testpmd>", 120)
+        self.session_third.send_expect("%s -c 0xf00 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test3 -- -i" % (self.dut.testpmd_path, self.sriov_vfs_port[1].pci), "testpmd>", 120)
         self.session_third.send_expect("mac_addr add 0 %s" % self.vf1_mac, "testpmd>")
         self.session_third.send_expect("set fwd rxonly", "testpmd>")
         self.session_third.send_expect("set promisc all off", "testpmd>")
diff --git a/tests/TestSuite_vhost_cuse_one_copy_one_vm.py b/tests/TestSuite_vhost_cuse_one_copy_one_vm.py
index 415ab0d..13f9426 100644
--- a/tests/TestSuite_vhost_cuse_one_copy_one_vm.py
+++ b/tests/TestSuite_vhost_cuse_one_copy_one_vm.py
@@ -128,13 +128,13 @@ class TestVhostCuseOneCopyOneVm(TestCase, IxiaPacketGenerator):
         if "jumbo" in self.running_case:
             self.jumbo = 1
             self.frame_sizes = [64, 128, 256, 512, 1024, 1280, 1518, 2048, 5000, 9000]
-            self.vm_testpmd = "./x86_64-native-linuxapp-gcc/app/testpmd -c 0x3 -n 3" \
+            self.vm_testpmd = self.dut.testpmd_path + " -c 0x3 -n 3" \
                 + " -- -i --txqflags=0xf00 " \
                 + "--disable-hw-vlan-filter --max-pkt-len 9600"
         else:
             self.jumbo = 0
             self.frame_sizes = [64, 128, 256, 512, 1024, 1280, 1518]
-            self.vm_testpmd = "./x86_64-native-linuxapp-gcc/app/testpmd -c 0x3 -n 3" \
+            self.vm_testpmd = self.dut.testpmd_path + " -c 0x3 -n 3" \
                 + " -- -i --txqflags=0xf00 --disable-hw-vlan-filter"
         self.dut.send_expect("rm -rf ./vhost.out", "#")
 
diff --git a/tests/TestSuite_vhost_loopback_performance_virtio_user.py b/tests/TestSuite_vhost_loopback_performance_virtio_user.py
index 4e1449d..8491cc9 100644
--- a/tests/TestSuite_vhost_loopback_performance_virtio_user.py
+++ b/tests/TestSuite_vhost_loopback_performance_virtio_user.py
@@ -89,12 +89,12 @@ class TestVhostLoopback(TestCase):
             self.dut.build_install_dpdk(self.dut.target)
 
             # Start the vhost user side
-            cmd = self.target + "/app/testpmd -n 4 -c 0x03 " + \
+            cmd = self.dut.testpmd_path + " -n 4 -c 0x03 " + \
                   "-m 2048 --file-prefix=vhost --vdev 'net_vhost0,iface=vhost-net,queues=1,client=0' -- -i"
             self.dut.send_expect(cmd, "testpmd>", 120)
             # Start the virtio_user side
             vhost_user = self.dut.new_session()
-            command_line_user = self.target + "/app/testpmd -n 4 -c 0x0c " + \
+            command_line_user = self.dut.testpmd_path + " -n 4 -c 0x0c " + \
                                 " -m 2048 --no-pci --file-prefix=virtio " + \
                                 " --vdev=net_virtio_user0,mac=00:01:02:03:04:05,path=./vhost-net" + \
                                 " -- -i --txqflags=0xf01 --disable-hw-vlan-filter"
@@ -148,12 +148,12 @@ class TestVhostLoopback(TestCase):
             self.dut.build_install_dpdk(self.dut.target)
 
             # Start the vhost user side
-            cmd = self.target + "/app/testpmd -n 4 -c 0x03 " + \
+            cmd = self.dut.testpmd_path + " -n 4 -c 0x03 " + \
                   "-m 2048 --file-prefix=vhost --vdev 'net_vhost0,iface=vhost-net,queues=1,client=0' -- -i"
             self.dut.send_expect(cmd, "testpmd>", 120)
             # Start the virtio_user side
             vhost_user = self.dut.new_session()
-            command_line_user = self.target + "/app/testpmd -n 4 -c 0x0c " + \
+            command_line_user = self.dut.testpmd_path + " -n 4 -c 0x0c " + \
                                 " -m 2048 --no-pci --file-prefix=virtio " + \
                                 " --vdev=net_virtio_user0,mac=00:01:02:03:04:05,path=./vhost-net " + \
                                 " -- -i --txqflags=0xf01 --disable-hw-vlan-filter"
@@ -207,12 +207,12 @@ class TestVhostLoopback(TestCase):
             self.dut.build_install_dpdk(self.dut.target)
 
             # Start the vhost user side
-            cmd = self.target + "/app/testpmd -n 4 -c 0x03 " + \
+            cmd = self.dut.testpmd_path + " -n 4 -c 0x03 " + \
                   "-m 2048 --file-prefix=vhost --vdev 'net_vhost0,iface=vhost-net,queues=1,client=0' -- -i"
             self.dut.send_expect(cmd, "testpmd>", 120)
             # Start the virtio_user side
             vhost_user = self.dut.new_session()
-            command_line_user = self.target + "/app/testpmd -n 4 -c 0x0c " + \
+            command_line_user = self.dut.testpmd_path + " -n 4 -c 0x0c " + \
                                 " -m 2048 --no-pci --file-prefix=virtio " + \
                                 " --vdev=net_virtio_user0,mac=00:01:02:03:04:05,path=./vhost-net" + \
                                 " -- -i --txqflags=0xf00 --disable-hw-vlan-filter"
diff --git a/tests/TestSuite_vhost_pmd_xstats.py b/tests/TestSuite_vhost_pmd_xstats.py
index 812cb94..a70f7ae 100644
--- a/tests/TestSuite_vhost_pmd_xstats.py
+++ b/tests/TestSuite_vhost_pmd_xstats.py
@@ -85,7 +85,7 @@ class TestVhostPmdXstats(TestCase):
         """
         Start testpmd in vm
         """
-        self.vm_testpmd = "./%s/app/testpmd -c 0x3 -n 4 -- -i --txqflags=0xf01" % self.target
+        self.vm_testpmd = "%s -c 0x3 -n 4 -- -i --txqflags=0xf01" % self.dut.testpmd_path
         if self.vm_dut is not None:
             self.vm_dut.send_expect(self.vm_testpmd, "testpmd>", 60)
 
@@ -144,8 +144,8 @@ class TestVhostPmdXstats(TestCase):
         """
         prepare all of the conditions for start
         """
-        self.dut.send_expect("./%s/app/testpmd -c %s -n %s --socket-mem 1024,0 --vdev 'net_vhost0,iface=vhost-net,queues=1' -- -i --nb-cores=1" %
-                             (self.target, self.coremask, self.dut.get_memory_channels()), "testpmd>", 60)
+        self.dut.send_expect("%s -c %s -n %s --socket-mem 1024,0 --vdev 'net_vhost0,iface=vhost-net,queues=1' -- -i --nb-cores=1" %
+                             (self.dut.testpmd_path, self.coremask, self.dut.get_memory_channels()), "testpmd>", 60)
         self.start_onevm()
         self.vm_testpmd_start()
         self.dut.send_expect("set fwd mac", "testpmd>", 60)
diff --git a/tests/TestSuite_vhost_qemu_pvp_performance.py b/tests/TestSuite_vhost_qemu_pvp_performance.py
index a9945d5..2f4bebe 100644
--- a/tests/TestSuite_vhost_qemu_pvp_performance.py
+++ b/tests/TestSuite_vhost_qemu_pvp_performance.py
@@ -106,9 +106,9 @@ class TestVhostUserOneCopyOneVm(TestCase):
         self.dut.send_expect("killall -s INT vhost-switch", "#")
 
         self.frame_sizes = [64, 128, 256, 512, 1024, 1500]
-        self.vm_testpmd_vector = self.target + "/app/testpmd -c 0x3 -n 3" \
+        self.vm_testpmd_vector = self.dut.testpmd_path + " -c 0x3 -n 3" \
                                  + " -- -i --txqflags=0xf01 --disable-hw-vlan-filter"
-        self.vm_testpmd_normal = self.target + "/app/testpmd -c 0x3 -n 3" \
+        self.vm_testpmd_normal = self.dut.testpmd_path + " -c 0x3 -n 3" \
                                  + " -- -i --txqflags=0xf00 --disable-hw-vlan-filter"
 
     def launch_vhost_sample(self):
diff --git a/tests/TestSuite_vhost_user_live_migration.py b/tests/TestSuite_vhost_user_live_migration.py
index 3f64244..ddba4f1 100644
--- a/tests/TestSuite_vhost_user_live_migration.py
+++ b/tests/TestSuite_vhost_user_live_migration.py
@@ -33,8 +33,8 @@ class TestVhostUserLiveMigration(TestCase):
         self.backup_tintf = self.tester.get_interface(self.backup_tport)
 
         # Use testpmd as vhost-user application on host/backup server 
-        self.vhost = "./x86_64-native-linuxapp-gcc/app/testpmd"
-        self.vm_testpmd = "./%s/app/testpmd -c 0x3 -n 4 -- -i" % self.target
+        self.vhost = self.dut.testpmd_path
+        self.vm_testpmd = "%s -c 0x3 -n 4 -- -i" % self.dut.testpmd_path
         self.virio_mac = "52:54:00:00:00:01"
         
 
diff --git a/tests/TestSuite_vhost_user_one_copy_one_vm.py b/tests/TestSuite_vhost_user_one_copy_one_vm.py
index f9e9430..33a040b 100644
--- a/tests/TestSuite_vhost_user_one_copy_one_vm.py
+++ b/tests/TestSuite_vhost_user_one_copy_one_vm.py
@@ -120,13 +120,13 @@ class TestVhostUserOneCopyOneVm(TestCase, IxiaPacketGenerator):
         if "jumbo" in self.running_case:
             self.jumbo = 1
             self.frame_sizes = [64, 128, 256, 512, 1024, 1280, 1518, 2048, 5000, 9000]
-            self.vm_testpmd = "./x86_64-native-linuxapp-gcc/app/testpmd -c 0x3 -n 3" \
+            self.vm_testpmd = self.dut.testpmd_path + " -c 0x3 -n 3" \
                 + " -- -i --txqflags=0xf00 " \
                 + "--disable-hw-vlan-filter --max-pkt-len 9600"
         else:
             self.jumbo = 0
             self.frame_sizes = [64, 128, 256, 512, 1024, 1280, 1518]
-            self.vm_testpmd = "./x86_64-native-linuxapp-gcc/app/testpmd -c 0x3 -n 3" \
+            self.vm_testpmd = self.dut.testpmd_path + " -c 0x3 -n 3" \
                 + " -- -i --txqflags=0xf00 --disable-hw-vlan-filter"
         self.dut.send_expect("rm -rf ./vhost.out", "#")
 
diff --git a/tests/TestSuite_virtio_iperf.py b/tests/TestSuite_virtio_iperf.py
index a0bd6e9..83f5778 100644
--- a/tests/TestSuite_virtio_iperf.py
+++ b/tests/TestSuite_virtio_iperf.py
@@ -146,7 +146,10 @@ class TestVirtioIperf(TestCase):
         self.dut_execut_cmd('modprobe uio')
         self.dut_execut_cmd('modprobe fuse')
         self.dut_execut_cmd('modprobe cuse')
-        self.dut_execut_cmd('insmod ./x86_64-native-linuxapp-gcc/kmod/igb_uio.ko')
+        if self.dut.installed_igb_uio == "yes":
+            self.dut_execut_cmd('modprobe igb_uio')
+        else:
+            self.dut_execut_cmd('insmod ./%s/kmod/igb_uio.ko' % self.target)
         self.dut_execut_cmd('insmod ./lib/librte_vhost/eventfd_link/eventfd_link.ko')
         self.dut.bind_interfaces_linux(self.drivername)
         self.launch_vhost_switch(self.coremask, 4, 0, 1)
@@ -226,7 +229,10 @@ class TestVirtioIperf(TestCase):
         self.dut_execut_cmd('modprobe uio')
         #self.dut_execut_cmd('modprobe fuse')
         #self.dut_execut_cmd('modprobe cuse')
-        self.dut_execut_cmd('insmod ./x86_64-native-linuxapp-gcc/kmod/igb_uio.ko')
+        if self.dut.installed_igb_uio == "yes":
+            self.dut_execut_cmd('modprobe igb_uio')
+        else:
+            self.dut_execut_cmd('insmod ./%s/kmod/igb_uio.ko' % self.target)
         self.dut_execut_cmd('insmod ./lib/librte_vhost/eventfd_link/eventfd_link.ko')
         self.dut.bind_interfaces_linux(self.drivername)
         self.launch_vhost_switch(self.coremask, 4, 0, 1)
diff --git a/tests/TestSuite_vxlan.py b/tests/TestSuite_vxlan.py
index 7d34cdd..5213db3 100644
--- a/tests/TestSuite_vxlan.py
+++ b/tests/TestSuite_vxlan.py
@@ -545,11 +545,10 @@ class TestVxlan(TestCase, IxiaPacketGenerator):
             self.dut.build_install_dpdk(self.target)
 
         
-        pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+        pmd_temp = self.dut.testpmd_path + " -c %(COREMASK)s -n " + \
             "%(CHANNEL)d -- -i --disable-rss --rxq=4 --txq=4" + \
             " --nb-cores=4 --portmask=%(PORT)s --txqflags=0x0"
-        pmd_cmd = pmd_temp % {'TARGET': self.target,
-                              'COREMASK': self.coremask,
+        pmd_cmd = pmd_temp % {'COREMASK': self.coremask,
                               'CHANNEL': self.dut.get_memory_channels(),
                               'PORT': self.portMask}
         self.dut.send_expect(pmd_cmd, "testpmd>", 30)
@@ -595,11 +594,10 @@ class TestVxlan(TestCase, IxiaPacketGenerator):
             self.dut.skip_setup = False
             self.dut.build_install_dpdk(self.target)
 
-        pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+        pmd_temp = self.dut.testpmd_path + " -c %(COREMASK)s -n " + \
             "%(CHANNEL)d -- -i --disable-rss --rxq=4 --txq=4" + \
             " --nb-cores=4 --portmask=%(PORT)s --txqflags=0x0"
-        pmd_cmd = pmd_temp % {'TARGET': self.target,
-                              'COREMASK': self.coremask,
+        pmd_cmd = pmd_temp % {'COREMASK': self.coremask,
                               'CHANNEL': self.dut.get_memory_channels(),
                               'PORT': self.portMask}
         self.dut.send_expect(pmd_cmd, "testpmd>", 30)
@@ -642,11 +640,10 @@ class TestVxlan(TestCase, IxiaPacketGenerator):
         verify vxlan packet checksum offload
         """
         # start testpmd with 2queue/1port
-        pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+        pmd_temp = self.dut.testpmd_path + " -c %(COREMASK)s -n " + \
             "%(CHANNEL)d -- -i --portmask=%(PORT)s " + \
             "--txqflags=0x0 --enable-rx-cksum"
-        pmd_cmd = pmd_temp % {'TARGET': self.target,
-                              'COREMASK': self.coremask,
+        pmd_cmd = pmd_temp % {'COREMASK': self.coremask,
                               'CHANNEL': self.dut.get_memory_channels(),
                               'PORT': self.portMask}
         self.dut.send_expect(pmd_cmd, "testpmd>", 30)
@@ -715,11 +712,10 @@ class TestVxlan(TestCase, IxiaPacketGenerator):
         not support ipv6 + sctp
         """
         # start testpmd with 2queue/1port
-        pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+        pmd_temp = self.dut.testpmd_path + " -c %(COREMASK)s -n " + \
             "%(CHANNEL)d -- -i --portmask=%(PORT)s " + \
             "--txqflags=0x0 --enable-rx-cksum"
-        pmd_cmd = pmd_temp % {'TARGET': self.target,
-                              'COREMASK': self.coremask,
+        pmd_cmd = pmd_temp % {'COREMASK': self.coremask,
                               'CHANNEL': self.dut.get_memory_channels(),
                               'PORT': self.portMask}
         self.dut.send_expect(pmd_cmd, "testpmd>", 30)
@@ -790,11 +786,10 @@ class TestVxlan(TestCase, IxiaPacketGenerator):
         """
         verify tunnel filter feature
         """
-        pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+        pmd_temp = self.dut.testpmd_path + " -c %(COREMASK)s -n " + \
             "%(CHANNEL)d -- -i --disable-rss --rxq=4 --txq=4" + \
             " --nb-cores=4 --portmask=%(PORT)s --txqflags=0x0"
-        pmd_cmd = pmd_temp % {'TARGET': self.target,
-                              'COREMASK': self.coremask,
+        pmd_cmd = pmd_temp % {'COREMASK': self.coremask,
                               'CHANNEL': self.dut.get_memory_channels(),
                               'PORT': self.portMask}
         self.dut.send_expect(pmd_cmd, "testpmd>", 30)
@@ -831,11 +826,10 @@ class TestVxlan(TestCase, IxiaPacketGenerator):
         config = VxlanTestConfig(self)
         config.outer_mac_dst = self.dut_port_mac
 
-        pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+        pmd_temp = self.dut.testpmd_path + " -c %(COREMASK)s -n " + \
             "%(CHANNEL)d -- -i --disable-rss --rxq=4 --txq=4" + \
             " --nb-cores=4 --portmask=%(PORT)s --txqflags=0x0"
-        pmd_cmd = pmd_temp % {'TARGET': self.target,
-                              'COREMASK': self.coremask,
+        pmd_cmd = pmd_temp % {'COREMASK': self.coremask,
                               'CHANNEL': self.dut.get_memory_channels(),
                               'PORT': self.portMask}
         self.dut.send_expect(pmd_cmd, "testpmd>", 30)
@@ -960,7 +954,7 @@ class TestVxlan(TestCase, IxiaPacketGenerator):
             socket=self.ports_socket)
         core_mask = utils.create_mask(core_list)
 
-        pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+        pmd_temp = self.dut.testpmd_path + " -c %(COREMASK)s -n " + \
             "%(CHANNEL)d -- -i --disable-rss --rxq=2 --txq=2" + \
             " --nb-cores=4 --portmask=%(PORT)s --txqflags=0x0"
 
@@ -971,7 +965,7 @@ class TestVxlan(TestCase, IxiaPacketGenerator):
                             % (perf_config['Packet'], tun_filter, recv_queue))
 
             if tun_filter == "None" and recv_queue == "Multi":
-                pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+                pmd_temp = self.dut.testpmd_path + " -c %(COREMASK)s -n " + \
                     "%(CHANNEL)d -- -i --rss-udp --rxq=2 --txq=2" + \
                     " --nb-cores=4 --portmask=%(PORT)s --txqflags=0x0"
 
@@ -1072,11 +1066,11 @@ class TestVxlan(TestCase, IxiaPacketGenerator):
 
             # multi queue and signle queue commands
             if recv_queue == 'Multi':
-                pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+                pmd_temp = self.dut.testpmd_path + " -c %(COREMASK)s -n " + \
                     "%(CHANNEL)d -- -i --disable-rss --rxq=2 --txq=2" + \
                     " --nb-cores=4 --portmask=%(PORT)s --txqflags=0x0"
             else:
-                pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+                pmd_temp = self.dut.testpmd_path + " -c %(COREMASK)s -n " + \
                     "%(CHANNEL)d -- -i --nb-cores=2 --portmask=%(PORT)s" + \
                     " --txqflags=0x0"
 
diff --git a/tests/TestSuite_vxlan_sample.py b/tests/TestSuite_vxlan_sample.py
index 752e0a7..59d6d61 100644
--- a/tests/TestSuite_vxlan_sample.py
+++ b/tests/TestSuite_vxlan_sample.py
@@ -101,7 +101,7 @@ class TestVxlanSample(TestCase):
         self.vm_dut = None
         self.tep_app = "./examples/tep_termination/build/tep_termination"
         self.vxlan_port = 4789
-        self.vm_testpmd = "./x86_64-native-linuxapp-gcc/app/testpmd -c f -n 3" \
+        self.vm_testpmd = self.dut.testpmd_path + " -c f -n 3" \
                           + " -- -i --txqflags=0xf00 --disable-hw-vlan"
 
         # params for tep_termination
-- 
1.9.1



More information about the dts mailing list