Refactor RFC2455 TRex traffic profile injection

The TRex RFC2455 traffic profile configures the duration of the traffic
injection. Once the traffic is started, the traffic profile should poll
the traffic injector client for the injection status. When the injection
is finished, the traffic execution should end.

Instead of this, the traffic profile waits a fixed time (using time.sleep
method) and then stops the traffic. This approach is not accurate and may
cause shorter injection periods.

JIRA: YARDSTICK-1197

Change-Id: I5090df81ef4ec7945ff6c1aff070656b48e0fe77
Signed-off-by: Rodolfo Alonso Hernandez <rodolfo.alonso.hernandez@intel.com>

17 files changed, 855 insertions, 1042 deletions

diff --git a/yardstick/benchmark/scenarios/networking/vnf_generic.py b/yardstick/benchmark/scenarios/networking/vnf_generic.py
index 4f7ef60d5..4d7c4f9be 100644
--- a/yardstick/benchmark/scenarios/networking/vnf_generic.py
+++ b/yardstick/benchmark/scenarios/networking/vnf_generic.py
@@ -136,7 +136,7 @@ class NetworkServiceTestCase(scenario_base.Scenario):
     def _get_duration(self):
         options = self.scenario_cfg.get('options', {})
         return options.get('duration',
-                           tprofile_base.TrafficProfile.DEFAULT_DURATION)
+                           tprofile_base.TrafficProfileConfig.DEFAULT_DURATION)
 
     def _fill_traffic_profile(self):
         tprofile = self._get_traffic_profile()
diff --git a/yardstick/common/utils.py b/yardstick/common/utils.py
index 108ee17bc..5b44ce0e2 100644
--- a/yardstick/common/utils.py
+++ b/yardstick/common/utils.py
@@ -409,13 +409,18 @@ class ErrorClass(object):
 
 
 class Timer(object):
-    def __init__(self, timeout=None):
+    def __init__(self, timeout=None, raise_exception=True):
         super(Timer, self).__init__()
         self.start = self.delta = None
         self._timeout = int(timeout) if timeout else None
+        self._timeout_flag = False
+        self._raise_exception = raise_exception
 
     def _timeout_handler(self, *args):
-        raise exceptions.TimerTimeout(timeout=self._timeout)
+        self._timeout_flag = True
+        if self._raise_exception:
+            raise exceptions.TimerTimeout(timeout=self._timeout)
+        self.__exit__()
 
     def __enter__(self):
         self.start = datetime.datetime.now()
@@ -432,6 +437,23 @@ class Timer(object):
     def __getattr__(self, item):
         return getattr(self.delta, item)
 
+    def __iter__(self):
+        self._raise_exception = False
+        return self.__enter__()
+
+    def next(self):  # pragma: no cover
+        # NOTE(ralonsoh): Python 2 support.
+        if not self._timeout_flag:
+            return datetime.datetime.now()
+        raise StopIteration()
+
+    def __next__(self):  # pragma: no cover
+        # NOTE(ralonsoh): Python 3 support.
+        return self.next()
+
+    def __del__(self):  # pragma: no cover
+        signal.alarm(0)
+
 
 def read_meminfo(ssh_client):
     """Read "/proc/meminfo" file and parse all keys and values"""
diff --git a/yardstick/network_services/traffic_profile/base.py b/yardstick/network_services/traffic_profile/base.py
index 4c3b29754..f4b5b178c 100644
--- a/yardstick/network_services/traffic_profile/base.py
+++ b/yardstick/network_services/traffic_profile/base.py
@@ -21,16 +21,21 @@ class TrafficProfileConfig(object):
 
     This object will parse and validate the traffic profile information.
     """
+
+    DEFAULT_SCHEMA = 'nsb:traffic_profile:0.1'
+    DEFAULT_FRAME_RATE = 100
+    DEFAULT_DURATION = 30
+
     def __init__(self, tp_config):
-        self.schema = tp_config.get('schema', 'nsb:traffic_profile:0.1')
+        self.schema = tp_config.get('schema', self.DEFAULT_SCHEMA)
         self.name = tp_config.get('name')
         self.description = tp_config.get('description')
         tprofile = tp_config['traffic_profile']
         self.traffic_type = tprofile.get('traffic_type')
-        self.frame_rate = tprofile.get('frame_rate')
+        self.frame_rate = tprofile.get('frame_rate', self.DEFAULT_FRAME_RATE)
         self.test_precision = tprofile.get('test_precision')
         self.packet_sizes = tprofile.get('packet_sizes')
-        self.duration = tprofile.get('duration')
+        self.duration = tprofile.get('duration', self.DEFAULT_DURATION)
         self.lower_bound = tprofile.get('lower_bound')
         self.upper_bound = tprofile.get('upper_bound')
         self.step_interval = tprofile.get('step_interval')
@@ -43,7 +48,6 @@ class TrafficProfile(object):
     """
     UPLINK = "uplink"
     DOWNLINK = "downlink"
-    DEFAULT_DURATION = 30
 
     @staticmethod
     def get(tp_config):
diff --git a/yardstick/network_services/traffic_profile/ixia_rfc2544.py b/yardstick/network_services/traffic_profile/ixia_rfc2544.py
index 73806f958..e105c2f55 100644
--- a/yardstick/network_services/traffic_profile/ixia_rfc2544.py
+++ b/yardstick/network_services/traffic_profile/ixia_rfc2544.py
@@ -95,7 +95,6 @@ class IXIARFC2544Profile(TrexProfile):
                 if not profile_data:
                     continue
                 self.profile_data = profile_data
-                self.get_streams(self.profile_data)
                 self.full_profile.update({vld_id: self.profile_data})
                 for intf in intfs:
                     yield traffic_generator.vnfd_helper.port_num(intf)
diff --git a/yardstick/network_services/traffic_profile/rfc2544.py b/yardstick/network_services/traffic_profile/rfc2544.py
index 83020c85c..c24e2f65a 100644
--- a/yardstick/network_services/traffic_profile/rfc2544.py
+++ b/yardstick/network_services/traffic_profile/rfc2544.py
@@ -11,190 +11,288 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-""" RFC2544 Throughput implemenation """
 
-from __future__ import absolute_import
-from __future__ import division
 import logging
 
-from trex_stl_lib.trex_stl_client import STLStream
-from trex_stl_lib.trex_stl_streams import STLFlowLatencyStats
-from trex_stl_lib.trex_stl_streams import STLTXCont
+from trex_stl_lib import api as Pkt
+from trex_stl_lib import trex_stl_client
+from trex_stl_lib import trex_stl_packet_builder_scapy
+from trex_stl_lib import trex_stl_streams
+
+from yardstick.network_services.traffic_profile import trex_traffic_profile
 
-from yardstick.network_services.traffic_profile.trex_traffic_profile \
-    import TrexProfile
 
 LOGGING = logging.getLogger(__name__)
+SRC_PORT = 'sport'
+DST_PORT = 'dport'
+
+
+class PortPgIDMap(object):
+    """Port and pg_id mapping class
+
+    "pg_id" is the identification STL library gives to each stream. In the
+    RFC2544Profile class, the traffic has a STLProfile per port, which contains
+    one or several streams, one per packet size defined in the IMIX test case
+    description.
+
+    Example of port <-> pg_id map:
+        self._port_pg_id_map = {
+            0: [1, 2, 3, 4],
+            1: [5, 6, 7, 8]
+        }
+    """
+
+    def __init__(self):
+        self._pg_id = 0
+        self._last_port = None
+        self._port_pg_id_map = {}
+
+    def add_port(self, port):
+        self._last_port = port
+        self._port_pg_id_map[port] = []
+
+    def get_pg_ids(self, port):
+        return self._port_pg_id_map.get(port)
+
+    def increase_pg_id(self, port=None):
+        port = self._last_port if not port else port
+        if port is None:
+            return
+        pg_id_list = self._port_pg_id_map.get(port)
+        if not pg_id_list:
+            self.add_port(port)
+            pg_id_list = self._port_pg_id_map[port]
+        self._pg_id += 1
+        pg_id_list.append(self._pg_id)
+        return self._pg_id
 
 
-class RFC2544Profile(TrexProfile):
-    """ This class handles rfc2544 implemenation. """
+class RFC2544Profile(trex_traffic_profile.TrexProfile):
+    """TRex RFC2544 traffic profile"""
+
+    TOLERANCE_LIMIT = 0.05
 
     def __init__(self, traffic_generator):
         super(RFC2544Profile, self).__init__(traffic_generator)
         self.generator = None
-        self.max_rate = None
-        self.min_rate = None
-        self.ports = None
-        self.rate = 100
-        self.drop_percent_at_max_tx = None
-        self.throughput_max = None
+        self.rate = self.config.frame_rate
+        self.max_rate = self.config.frame_rate
+        self.min_rate = 0
+        self.drop_percent_max = 0
 
     def register_generator(self, generator):
         self.generator = generator
 
-    def execute_traffic(self, traffic_generator=None):
-        """ Generate the stream and run traffic on the given ports """
+    def stop_traffic(self, traffic_generator=None):
+        """"Stop traffic injection, reset counters and remove streams"""
         if traffic_generator is not None and self.generator is None:
             self.generator = traffic_generator
 
-        if self.ports is not None:
-            return
+        self.generator.client.stop()
+        self.generator.client.reset()
+        self.generator.client.remove_all_streams()
+
+    def execute_traffic(self, traffic_generator=None):
+        """Generate the stream and run traffic on the given ports
+
+        :param traffic_generator: (TrexTrafficGenRFC) traffic generator
+        :return ports: (list of int) indexes of ports
+                port_pg_id: (dict) port indexes and pg_id [1] map
+        [1] https://trex-tgn.cisco.com/trex/doc/cp_stl_docs/api/
+            profile_code.html#stlstream-modes
+        """
+        if traffic_generator is not None and self.generator is None:
+            self.generator = traffic_generator
 
-        self.ports = []
+        port_pg_id = PortPgIDMap()
+        ports = []
         for vld_id, intfs in sorted(self.generator.networks.items()):
             profile_data = self.params.get(vld_id)
-            # no profile for this port
             if not profile_data:
                 continue
-            # correlated traffic doesn't use public traffic?
-            if vld_id.startswith(self.DOWNLINK) and \
-                self.generator.rfc2544_helper.correlated_traffic:
+            if (vld_id.startswith(self.DOWNLINK) and
+                    self.generator.rfc2544_helper.correlated_traffic):
                 continue
             for intf in intfs:
-                port = self.generator.port_num(intf)
-                self.ports.append(port)
-                self.generator.client.add_streams(self.get_streams(profile_data), ports=port)
-
-        self.max_rate = self.rate
-        self.min_rate = 0
-        self.generator.client.start(ports=self.ports, mult=self.get_multiplier(),
-                                    duration=30, force=True)
-        self.drop_percent_at_max_tx = 0
-        self.throughput_max = 0
-
-    def get_multiplier(self):
-        """ Get the rate at which next iteration to run """
-        self.rate = round((self.max_rate + self.min_rate) / 2.0, 2)
-        multiplier = round(self.rate / self.pps, 2)
-        return str(multiplier)
-
-    def get_drop_percentage(self, generator=None):
-        """ Calculate the drop percentage and run the traffic """
-        if generator is None:
-            generator = self.generator
-        run_duration = self.generator.RUN_DURATION
-        samples = self.generator.generate_samples(self.ports)
-
-        in_packets = sum([value['in_packets'] for value in samples.values()])
-        out_packets = sum([value['out_packets'] for value in samples.values()])
-
-        packet_drop = abs(out_packets - in_packets)
-        drop_percent = 100.0
-        try:
-            drop_percent = round((packet_drop / float(out_packets)) * 100, 5)
-        except ZeroDivisionError:
-            LOGGING.info('No traffic is flowing')
+                port_num = int(self.generator.port_num(intf))
+                ports.append(port_num)
+                port_pg_id.add_port(port_num)
+                profile = self._create_profile(profile_data,
+                                               self.rate, port_pg_id)
+                self.generator.client.add_streams(profile, ports=[port_num])
+
+        self.generator.client.start(ports=ports,
+                                    duration=self.config.duration,
+                                    force=True)
+        return ports, port_pg_id
+
+    def _create_profile(self, profile_data, rate, port_pg_id):
+        """Create a STL profile (list of streams) for a port"""
+        streams = []
+        for packet_name in profile_data:
+            imix = (profile_data[packet_name].
+                    get('outer_l2', {}).get('framesize'))
+            imix_data = self._create_imix_data(imix)
+            self._create_vm(profile_data[packet_name])
+            _streams = self._create_streams(imix_data, rate, port_pg_id)
+            streams.extend(_streams)
+        return trex_stl_streams.STLProfile(streams)
+
+    def _create_imix_data(self, imix):
+        """Generate the IMIX distribution for a STL profile
+
+        The input information is the framesize dictionary in a test case
+        traffic profile definition. E.g.:
+          downlink_0:
+            ipv4:
+              id: 2
+                outer_l2:
+                  framesize:
+                    64B: 10
+                    128B: 20
+                    ...
+
+        This function normalizes the sum of framesize weights to 100 and
+        returns a dictionary of frame sizes in bytes and weight in percentage.
+        E.g.:
+          imix_count = {64: 25, 128: 75}
+
+        :param imix: (dict) IMIX size and weight
+        """
+        imix_count = {}
+        if not imix:
+            return imix_count
+
+        imix_count = {size.upper().replace('B', ''): int(weight)
+                      for size, weight in imix.items()}
+        imix_sum = sum(imix_count.values())
+        if imix_sum <= 0:
+            imix_count = {64: 100}
+            imix_sum = 100
+
+        weight_normalize = float(imix_sum) / 100
+        return {size: float(weight) / weight_normalize
+                for size, weight in imix_count.items()}
+
+    def _create_vm(self, packet_definition):
+        """Create the STL Raw instructions"""
+        self.ether_packet = Pkt.Ether()
+        self.ip_packet = Pkt.IP()
+        self.ip6_packet = None
+        self.udp_packet = Pkt.UDP()
+        self.udp[DST_PORT] = 'UDP.dport'
+        self.udp[SRC_PORT] = 'UDP.sport'
+        self.qinq = False
+        self.vm_flow_vars = []
+        outer_l2 = packet_definition.get('outer_l2')
+        outer_l3v4 = packet_definition.get('outer_l3v4')
+        outer_l3v6 = packet_definition.get('outer_l3v6')
+        outer_l4 = packet_definition.get('outer_l4')
+        if outer_l2:
+            self._set_outer_l2_fields(outer_l2)
+        if outer_l3v4:
+            self._set_outer_l3v4_fields(outer_l3v4)
+        if outer_l3v6:
+            self._set_outer_l3v6_fields(outer_l3v6)
+        if outer_l4:
+            self._set_outer_l4_fields(outer_l4)
+        self.trex_vm = trex_stl_packet_builder_scapy.STLScVmRaw(
+            self.vm_flow_vars)
+
+    def _create_single_packet(self, size=64):
+        size -= 4
+        ether_packet = self.ether_packet
+        ip_packet = self.ip6_packet if self.ip6_packet else self.ip_packet
+        udp_packet = self.udp_packet
+        if self.qinq:
+            qinq_packet = self.qinq_packet
+            base_pkt = ether_packet / qinq_packet / ip_packet / udp_packet
+        else:
+            base_pkt = ether_packet / ip_packet / udp_packet
+        pad = max(0, size - len(base_pkt)) * 'x'
+        return trex_stl_packet_builder_scapy.STLPktBuilder(
+            pkt=base_pkt / pad, vm=self.trex_vm)
+
+    def _create_streams(self, imix_data, rate, port_pg_id):
+        """Create a list of streams per packet size
+
+        The STL TX mode speed of the generated streams will depend on the frame
+        weight and the frame rate. Both the frame weight and the total frame
+        rate are normalized to 100. The STL TX mode speed, defined in
+        percentage, is the combitation of both percentages. E.g.:
+          frame weight = 100
+          rate = 90
+            --> STLTXmode percentage = 10 (%)
+
+          frame weight = 80
+          rate = 50
+            --> STLTXmode percentage = 40 (%)
+
+        :param imix_data: (dict) IMIX size and weight
+        :param rate: (float) normalized [0..100] total weight
+        :param pg_id: (PortPgIDMap) port / pg_id (list) map
+        """
+        streams = []
+        for size, weight in ((int(size), float(weight)) for (size, weight)
+                             in imix_data.items() if float(weight) > 0):
+            packet = self._create_single_packet(size)
+            pg_id = port_pg_id.increase_pg_id()
+            stl_flow = trex_stl_streams.STLFlowLatencyStats(pg_id=pg_id)
+            mode = trex_stl_streams.STLTXCont(percentage=weight * rate / 100)
+            streams.append(trex_stl_client.STLStream(
+                packet=packet, flow_stats=stl_flow, mode=mode))
+        return streams
+
+    def get_drop_percentage(self, samples, tol_low, tol_high,
+                            correlated_traffic):
+        """Calculate the drop percentage and run the traffic"""
+        tx_rate_fps = 0
+        rx_rate_fps = 0
+        for sample in samples:
+            tx_rate_fps += sum(
+                port['tx_throughput_fps'] for port in sample.values())
+            rx_rate_fps += sum(
+                port['rx_throughput_fps'] for port in sample.values())
+        tx_rate_fps = round(float(tx_rate_fps) / len(samples), 2)
+        rx_rate_fps = round(float(rx_rate_fps) / len(samples), 2)
 
         # TODO(esm): RFC2544 doesn't tolerate packet loss, why do we?
-        tolerance_low = generator.rfc2544_helper.tolerance_low
-        tolerance_high = generator.rfc2544_helper.tolerance_high
-
-        tx_rate = out_packets / run_duration
-        rx_rate = in_packets / run_duration
-
-        throughput_max = self.throughput_max
-        drop_percent_at_max_tx = self.drop_percent_at_max_tx
+        out_packets = sum(port['out_packets'] for port in samples[-1].values())
+        in_packets = sum(port['in_packets'] for port in samples[-1].values())
+        drop_percent = 100.0
 
-        if self.drop_percent_at_max_tx is None:
-            self.rate = tx_rate
-            self.first_run = False
+        # https://tools.ietf.org/html/rfc2544#section-26.3
+        if out_packets:
+            drop_percent = round(
+                (float(abs(out_packets - in_packets)) / out_packets) * 100, 5)
 
-        if drop_percent > tolerance_high:
-            # TODO(esm): why don't we discard results that are out of tolerance?
+        tol_high = tol_high if tol_high > self.TOLERANCE_LIMIT else tol_high
+        tol_low = tol_low if tol_low > self.TOLERANCE_LIMIT else tol_low
+        if drop_percent > tol_high:
             self.max_rate = self.rate
-            if throughput_max == 0:
-                throughput_max = rx_rate
-                drop_percent_at_max_tx = drop_percent
-
-        elif drop_percent >= tolerance_low:
-            # TODO(esm): why do we update the samples dict in this case
-            #            and not update our tracking values?
-            throughput_max = rx_rate
-            drop_percent_at_max_tx = drop_percent
-
-        elif drop_percent >= self.drop_percent_at_max_tx:
-            # TODO(esm): why don't we discard results that are out of tolerance?
+        elif drop_percent < tol_low:
             self.min_rate = self.rate
-            self.drop_percent_at_max_tx = drop_percent_at_max_tx = drop_percent
-            self.throughput_max = throughput_max = rx_rate
+        # else:
+            # NOTE(ralonsoh): the test should finish here
+            # pass
+        last_rate = self.rate
+        self.rate = round(float(self.max_rate + self.min_rate) / 2.0, 5)
 
-        else:
-            # TODO(esm): why don't we discard results that are out of tolerance?
-            self.min_rate = self.rate
+        throughput = rx_rate_fps * 2 if correlated_traffic else rx_rate_fps
 
-        generator.clear_client_stats(self.ports)
-        generator.start_client(self.ports, mult=self.get_multiplier(),
-                               duration=run_duration, force=True)
+        if drop_percent > self.drop_percent_max:
+            self.drop_percent_max = drop_percent
 
-        # if correlated traffic update the Throughput
-        if generator.rfc2544_helper.correlated_traffic:
-            throughput_max *= 2
+        latency = {port_num: value['latency']
+                   for port_num, value in samples[-1].items()}
 
-        samples.update({
-            'TxThroughput': tx_rate,
-            'RxThroughput': rx_rate,
+        output = {
+            'TxThroughput': tx_rate_fps,
+            'RxThroughput': rx_rate_fps,
             'CurrentDropPercentage': drop_percent,
-            'Throughput': throughput_max,
-            'DropPercentage': drop_percent_at_max_tx,
-        })
-
-        return samples
-
-    def execute_latency(self, generator=None, samples=None):
-        if generator is not None and self.generator is None:
-            self.generator = generator
-
-        if samples is None:
-            samples = self.generator.generate_samples()
-
-        self.pps, multiplier = self.calculate_pps(samples)
-        self.ports = []
-        self.pg_id = self.params['traffic_profile'].get('pg_id', 1)
-        for vld_id, intfs in sorted(self.generator.networks.items()):
-            profile_data = self.params.get(vld_id)
-            if not profile_data:
-                continue
-            # correlated traffic doesn't use public traffic?
-            if vld_id.startswith(self.DOWNLINK) and \
-                self.generator.rfc2544_helper.correlated_traffic:
-                continue
-            for intf in intfs:
-                port = self.generator.port_num(intf)
-                self.ports.append(port)
-                self.generator.client.add_streams(self.get_streams(profile_data), ports=port)
-
-        self.generator.start_client(ports=self.ports, mult=str(multiplier),
-                                    duration=120, force=True)
-        self.first_run = False
-
-    def calculate_pps(self, samples):
-        pps = round(samples['Throughput'] / 2, 2)
-        multiplier = round(self.rate / self.pps, 2)
-        return pps, multiplier
-
-    def create_single_stream(self, packet_size, pps, isg=0):
-        packet = self._create_single_packet(packet_size)
-        if pps:
-            stl_mode = STLTXCont(pps=pps)
-        else:
-            stl_mode = STLTXCont(pps=self.pps)
-        if self.pg_id:
-            LOGGING.debug("pg_id: %s", self.pg_id)
-            stl_flow_stats = STLFlowLatencyStats(pg_id=self.pg_id)
-            stream = STLStream(isg=isg, packet=packet, mode=stl_mode,
-                               flow_stats=stl_flow_stats)
-            self.pg_id += 1
-        else:
-            stream = STLStream(isg=isg, packet=packet, mode=stl_mode)
-        return stream
+            'Throughput': throughput,
+            'DropPercentage': self.drop_percent_max,
+            'Rate': last_rate,
+            'Latency': latency
+        }
+        return output
diff --git a/yardstick/network_services/traffic_profile/trex_traffic_profile.py b/yardstick/network_services/traffic_profile/trex_traffic_profile.py
index f5e3923d5..ed0355fa5 100644
--- a/yardstick/network_services/traffic_profile/trex_traffic_profile.py
+++ b/yardstick/network_services/traffic_profile/trex_traffic_profile.py
@@ -19,21 +19,16 @@ from random import SystemRandom
 import ipaddress
 
 import six
-
-from yardstick.common import exceptions as y_exc
-from yardstick.network_services.traffic_profile import base
-from trex_stl_lib.trex_stl_client import STLStream
-from trex_stl_lib.trex_stl_streams import STLFlowLatencyStats
-from trex_stl_lib.trex_stl_streams import STLTXCont
-from trex_stl_lib.trex_stl_streams import STLProfile
 from trex_stl_lib.trex_stl_packet_builder_scapy import STLVmWrFlowVar
 from trex_stl_lib.trex_stl_packet_builder_scapy import STLVmFlowVarRepeatableRandom
 from trex_stl_lib.trex_stl_packet_builder_scapy import STLVmFlowVar
-from trex_stl_lib.trex_stl_packet_builder_scapy import STLPktBuilder
-from trex_stl_lib.trex_stl_packet_builder_scapy import STLScVmRaw
 from trex_stl_lib.trex_stl_packet_builder_scapy import STLVmFixIpv4
 from trex_stl_lib import api as Pkt
 
+from yardstick.common import exceptions as y_exc
+from yardstick.network_services.traffic_profile import base
+
+
 SRC = 'src'
 DST = 'dst'
 ETHERNET = 'Ethernet'
@@ -342,115 +337,6 @@ class TrexProfile(base.TrafficProfile):
         if 'dstport' in outer_l4:
             self._set_proto_addr(UDP, DST_PORT, outer_l4['dstport'], outer_l4['count'])
 
-    def generate_imix_data(self, packet_definition):
-        """ generate packet size for a given traffic profile """
-        imix_count = {}
-        imix_data = {}
-        if not packet_definition:
-            return imix_count
-        imix = packet_definition.get('framesize')
-        if imix:
-            for size in imix:
-                data = imix[size]
-                imix_data[int(size[:-1])] = int(data)
-            imix_sum = sum(imix_data.values())
-            if imix_sum > 100:
-                raise SystemExit("Error in IMIX data")
-            elif imix_sum < 100:
-                imix_data[64] = imix_data.get(64, 0) + (100 - imix_sum)
-
-            avg_size = 0.0
-            for size in imix_data:
-                count = int(imix_data[size])
-                if count:
-                    avg_size += round(size * count / 100, 2)
-                    pps = round(self.pps * count / 100, 0)
-                    imix_count[size] = pps
-            self.rate = round(1342177280 / avg_size, 0) * 2
-            logging.debug("Imax: %s rate: %s", imix_count, self.rate)
-        return imix_count
-
-    def get_streams(self, profile_data):
-        """ generate trex stream
-        :param profile_data:
-        :type profile_data:
-        """
-        self.streams = []
-        self.pps = self.params['traffic_profile'].get('frame_rate', 100)
-        for packet_name in profile_data:
-            outer_l2 = profile_data[packet_name].get('outer_l2')
-            imix_data = self.generate_imix_data(outer_l2)
-            if not imix_data:
-                imix_data = {64: self.pps}
-            self.generate_vm(profile_data[packet_name])
-            for size in imix_data:
-                self._generate_streams(size, imix_data[size])
-        self._generate_profile()
-        return self.profile
-
-    def generate_vm(self, packet_definition):
-        """ generate  trex vm with flows setup """
-        self.ether_packet = Pkt.Ether()
-        self.ip_packet = Pkt.IP()
-        self.ip6_packet = None
-        self.udp_packet = Pkt.UDP()
-        self.udp[DST_PORT] = 'UDP.dport'
-        self.udp[SRC_PORT] = 'UDP.sport'
-        self.qinq = False
-        self.vm_flow_vars = []
-        outer_l2 = packet_definition.get('outer_l2', None)
-        outer_l3v4 = packet_definition.get('outer_l3v4', None)
-        outer_l3v6 = packet_definition.get('outer_l3v6', None)
-        outer_l4 = packet_definition.get('outer_l4', None)
-        if outer_l2:
-            self._set_outer_l2_fields(outer_l2)
-        if outer_l3v4:
-            self._set_outer_l3v4_fields(outer_l3v4)
-        if outer_l3v6:
-            self._set_outer_l3v6_fields(outer_l3v6)
-        if outer_l4:
-            self._set_outer_l4_fields(outer_l4)
-        self.trex_vm = STLScVmRaw(self.vm_flow_vars)
-
-    def generate_packets(self):
-        """ generate packets from trex TG """
-        base_pkt = self.base_pkt
-        size = self.fsize - 4
-        pad = max(0, size - len(base_pkt)) * 'x'
-        self.packets = [STLPktBuilder(pkt=base_pkt / pad,
-                                      vm=vm) for vm in self.vms]
-
-    def _create_single_packet(self, size=64):
-        size = size - 4
-        ether_packet = self.ether_packet
-        ip_packet = self.ip6_packet if self.ip6_packet else self.ip_packet
-        udp_packet = self.udp_packet
-        if self.qinq:
-            qinq_packet = self.qinq_packet
-            base_pkt = ether_packet / qinq_packet / ip_packet / udp_packet
-        else:
-            base_pkt = ether_packet / ip_packet / udp_packet
-        pad = max(0, size - len(base_pkt)) * 'x'
-        packet = STLPktBuilder(pkt=base_pkt / pad, vm=self.trex_vm)
-        return packet
-
-    def _create_single_stream(self, packet_size, pps, isg=0):
-        packet = self._create_single_packet(packet_size)
-        if self.pg_id:
-            self.pg_id += 1
-            stl_flow = STLFlowLatencyStats(pg_id=self.pg_id)
-            stream = STLStream(isg=isg, packet=packet, mode=STLTXCont(pps=pps),
-                               flow_stats=stl_flow)
-        else:
-            stream = STLStream(isg=isg, packet=packet, mode=STLTXCont(pps=pps))
-        return stream
-
-    def _generate_streams(self, packet_size, pps):
-        self.streams.append(self._create_single_stream(packet_size, pps))
-
-    def _generate_profile(self):
-        self.profile = STLProfile(self.streams)
-
     @classmethod
     def _count_ip(cls, start_ip, end_ip):
         start = ipaddress.ip_address(six.u(start_ip))
diff --git a/yardstick/network_services/vnf_generic/vnf/sample_vnf.py b/yardstick/network_services/vnf_generic/vnf/sample_vnf.py
index ef8b3f126..8e0e29675 100644
--- a/yardstick/network_services/vnf_generic/vnf/sample_vnf.py
+++ b/yardstick/network_services/vnf_generic/vnf/sample_vnf.py
@@ -11,20 +11,17 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-""" Base class implementation for generic vnf implementation """
 
-from collections import Mapping
 import logging
 from multiprocessing import Queue, Value, Process
 
 import os
 import posixpath
 import re
+import six
 import subprocess
 import time
 
-import six
-
 from trex_stl_lib.trex_stl_client import LoggerApi
 from trex_stl_lib.trex_stl_client import STLClient
 from trex_stl_lib.trex_stl_exceptions import STLError
@@ -375,39 +372,14 @@ class ClientResourceHelper(ResourceHelper):
             LOG.error('TRex client not connected')
             return {}
 
-    def generate_samples(self, ports, key=None, default=None):
-        # needs to be used ports
-        last_result = self.get_stats(ports)
-        key_value = last_result.get(key, default)
-
-        if not isinstance(last_result, Mapping):  # added for mock unit test
-            self._terminated.value = 1
-            return {}
-
-        samples = {}
-        # recalculate port for interface and see if it matches ports provided
-        for intf in self.vnfd_helper.interfaces:
-            name = intf["name"]
-            port = self.vnfd_helper.port_num(name)
-            if port in ports:
-                xe_value = last_result.get(port, {})
-                samples[name] = {
-                    "rx_throughput_fps": float(xe_value.get("rx_pps", 0.0)),
-                    "tx_throughput_fps": float(xe_value.get("tx_pps", 0.0)),
-                    "rx_throughput_mbps": float(xe_value.get("rx_bps", 0.0)),
-                    "tx_throughput_mbps": float(xe_value.get("tx_bps", 0.0)),
-                    "in_packets": int(xe_value.get("ipackets", 0)),
-                    "out_packets": int(xe_value.get("opackets", 0)),
-                }
-                if key:
-                    samples[name][key] = key_value
-        return samples
+    def _get_samples(self, ports, port_pg_id=False):
+        raise NotImplementedError()
 
     def _run_traffic_once(self, traffic_profile):
         traffic_profile.execute_traffic(self)
         self.client_started.value = 1
         time.sleep(self.RUN_DURATION)
-        samples = self.generate_samples(traffic_profile.ports)
+        samples = self._get_samples(traffic_profile.ports)
         time.sleep(self.QUEUE_WAIT_TIME)
         self._queue.put(samples)
 
diff --git a/yardstick/network_services/vnf_generic/vnf/tg_rfc2544_trex.py b/yardstick/network_services/vnf_generic/vnf/tg_rfc2544_trex.py
index 4e9f4bdc1..07cec6745 100644
--- a/yardstick/network_services/vnf_generic/vnf/tg_rfc2544_trex.py
+++ b/yardstick/network_services/vnf_generic/vnf/tg_rfc2544_trex.py
@@ -11,74 +11,45 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-""" Trex traffic generation definitions which implements rfc2544 """
 
-from __future__ import absolute_import
-from __future__ import print_function
-import time
 import logging
-from collections import Mapping
-
-from yardstick.network_services.vnf_generic.vnf.tg_trex import TrexTrafficGen
-from yardstick.network_services.vnf_generic.vnf.sample_vnf import Rfc2544ResourceHelper
-from yardstick.network_services.vnf_generic.vnf.tg_trex import TrexResourceHelper
-
-LOGGING = logging.getLogger(__name__)
+import time
 
+from yardstick.common import utils
+from yardstick.network_services.vnf_generic.vnf import sample_vnf
+from yardstick.network_services.vnf_generic.vnf import tg_trex
 
-class TrexRfc2544ResourceHelper(Rfc2544ResourceHelper):
 
-    def is_done(self):
-        return self.latency and self.iteration.value > 10
+LOGGING = logging.getLogger(__name__)
 
 
-class TrexRfcResourceHelper(TrexResourceHelper):
+class TrexRfcResourceHelper(tg_trex.TrexResourceHelper):
 
-    LATENCY_TIME_SLEEP = 120
-    RUN_DURATION = 30
-    WAIT_TIME = 3
+    SAMPLING_PERIOD = 2
+    TRANSIENT_PERIOD = 10
 
-    def __init__(self, setup_helper, rfc_helper_type=None):
+    def __init__(self, setup_helper):
         super(TrexRfcResourceHelper, self).__init__(setup_helper)
-
-        if rfc_helper_type is None:
-            rfc_helper_type = TrexRfc2544ResourceHelper
-
-        self.rfc2544_helper = rfc_helper_type(self.scenario_helper)
+        self.rfc2544_helper = sample_vnf.Rfc2544ResourceHelper(
+            self.scenario_helper)
 
     def _run_traffic_once(self, traffic_profile):
-        if self._terminated.value:
-            return
-
-        traffic_profile.execute_traffic(self)
         self.client_started.value = 1
-        time.sleep(self.RUN_DURATION)
-        self.client.stop(traffic_profile.ports)
-        time.sleep(self.WAIT_TIME)
-        samples = traffic_profile.get_drop_percentage(self)
-        self._queue.put(samples)
-
-        if not self.rfc2544_helper.is_done():
-            return
-
-        self.client.stop(traffic_profile.ports)
-        self.client.reset(ports=traffic_profile.ports)
-        self.client.remove_all_streams(traffic_profile.ports)
-        traffic_profile.execute_traffic_latency(samples=samples)
-        multiplier = traffic_profile.calculate_pps(samples)[1]
-        for _ in range(5):
-            time.sleep(self.LATENCY_TIME_SLEEP)
-            self.client.stop(traffic_profile.ports)
-            time.sleep(self.WAIT_TIME)
-            last_res = self.client.get_stats(traffic_profile.ports)
-            if not isinstance(last_res, Mapping):
-                self._terminated.value = 1
-                continue
-            self.generate_samples(traffic_profile.ports, 'latency', {})
-            self._queue.put(samples)
-            self.client.start(mult=str(multiplier),
-                              ports=traffic_profile.ports,
-                              duration=120, force=True)
+        ports, port_pg_id = traffic_profile.execute_traffic(self)
+
+        samples = []
+        timeout = int(traffic_profile.config.duration) - self.TRANSIENT_PERIOD
+        time.sleep(self.TRANSIENT_PERIOD)
+        for _ in utils.Timer(timeout=timeout):
+            samples.append(self._get_samples(ports, port_pg_id=port_pg_id))
+            time.sleep(self.SAMPLING_PERIOD)
+
+        traffic_profile.stop_traffic(self)
+        output = traffic_profile.get_drop_percentage(
+            samples, self.rfc2544_helper.tolerance_low,
+            self.rfc2544_helper.tolerance_high,
+            self.rfc2544_helper.correlated_traffic)
+        self._queue.put(output)
 
     def start_client(self, ports, mult=None, duration=None, force=True):
         self.client.start(ports=ports, mult=mult, duration=duration, force=force)
@@ -86,12 +57,8 @@ class TrexRfcResourceHelper(TrexResourceHelper):
     def clear_client_stats(self, ports):
         self.client.clear_stats(ports=ports)
 
-    def collect_kpi(self):
-        self.rfc2544_helper.iteration.value += 1
-        return super(TrexRfcResourceHelper, self).collect_kpi()
-
 
-class TrexTrafficGenRFC(TrexTrafficGen):
+class TrexTrafficGenRFC(tg_trex.TrexTrafficGen):
     """
     This class handles mapping traffic profile and generating
     traffic for rfc2544 testcase.
diff --git a/yardstick/network_services/vnf_generic/vnf/tg_trex.py b/yardstick/network_services/vnf_generic/vnf/tg_trex.py
index 0084a124c..80b42e22d 100644
--- a/yardstick/network_services/vnf_generic/vnf/tg_trex.py
+++ b/yardstick/network_services/vnf_generic/vnf/tg_trex.py
@@ -13,7 +13,6 @@
 # limitations under the License.
 """ Trex acts as traffic generation and vnf definitions based on IETS Spec """
 
-from __future__ import absolute_import
 import logging
 import os
 
@@ -25,6 +24,7 @@ from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNFTraff
 from yardstick.network_services.vnf_generic.vnf.sample_vnf import ClientResourceHelper
 from yardstick.network_services.vnf_generic.vnf.sample_vnf import DpdkVnfSetupEnvHelper
 
+
 LOG = logging.getLogger(__name__)
 
 
@@ -165,6 +165,30 @@ class TrexResourceHelper(ClientResourceHelper):
         cmd = "sudo fuser -n tcp %s %s -k > /dev/null 2>&1"
         self.ssh_helper.execute(cmd % (self.SYNC_PORT, self.ASYNC_PORT))
 
+    def _get_samples(self, ports, port_pg_id=None):
+        stats = self.get_stats(ports)
+        samples = {}
+        for pname in (intf['name'] for intf in self.vnfd_helper.interfaces):
+            port_num = self.vnfd_helper.port_num(pname)
+            port_stats = stats.get(port_num, {})
+            samples[pname] = {
+                'rx_throughput_fps': float(port_stats.get('rx_pps', 0.0)),
+                'tx_throughput_fps': float(port_stats.get('tx_pps', 0.0)),
+                'rx_throughput_bps': float(port_stats.get('rx_bps', 0.0)),
+                'tx_throughput_bps': float(port_stats.get('tx_bps', 0.0)),
+                'in_packets': int(port_stats.get('ipackets', 0)),
+                'out_packets': int(port_stats.get('opackets', 0)),
+            }
+
+            pg_id_list = port_pg_id.get_pg_ids(port_num)
+            samples[pname]['latency'] = {}
+            for pg_id in pg_id_list:
+                latency_global = stats.get('latency', {})
+                pg_latency = latency_global.get(pg_id, {}).get('latency')
+                samples[pname]['latency'][pg_id] = pg_latency
+
+        return samples
+
 
 class TrexTrafficGen(SampleVNFTrafficGen):
     """
diff --git a/yardstick/tests/unit/benchmark/contexts/standalone/test_model.py b/yardstick/tests/unit/benchmark/contexts/standalone/test_model.py
index 2cf1d92d7..246a5b2b9 100644
--- a/yardstick/tests/unit/benchmark/contexts/standalone/test_model.py
+++ b/yardstick/tests/unit/benchmark/contexts/standalone/test_model.py
@@ -549,5 +549,5 @@ class OvsDeployTestCase(unittest.TestCase):
                     'ovs_version': ovs_version,
                     'dpdk_version': dpdk_version,
                     'proxy': 'test_proxy'})
-            mock_execute.assert_called_with(cmd)
-            mock_env_get.assert_called_with('http_proxy', '')
+            mock_execute.assert_called_once_with(cmd)
+            mock_env_get.assert_has_calls([mock.call('http_proxy', '')])
diff --git a/yardstick/tests/unit/common/test_utils.py b/yardstick/tests/unit/common/test_utils.py
index 5fd91c87f..31b10e6da 100644
--- a/yardstick/tests/unit/common/test_utils.py
+++ b/yardstick/tests/unit/common/test_utils.py
@@ -1174,6 +1174,17 @@ class TimerTestCase(unittest.TestCase):
             with utils.Timer(timeout=1):
                 time.sleep(2)
 
+    def test__enter_with_timeout_no_exception(self):
+        with utils.Timer(timeout=1, raise_exception=False):
+            time.sleep(2)
+
+    def test__iter(self):
+        iterations = []
+        for i in utils.Timer(timeout=2):
+            iterations.append(i)
+            time.sleep(1.1)
+        self.assertEqual(2, len(iterations))
+
 
 class WaitUntilTrueTestCase(unittest.TestCase):
 
diff --git a/yardstick/tests/unit/network_services/traffic_profile/test_base.py b/yardstick/tests/unit/network_services/traffic_profile/test_base.py
index cf4888d82..55276af58 100644
--- a/yardstick/tests/unit/network_services/traffic_profile/test_base.py
+++ b/yardstick/tests/unit/network_services/traffic_profile/test_base.py
@@ -77,6 +77,12 @@ class TestDummyProfile(unittest.TestCase):
 class TrafficProfileConfigTestCase(unittest.TestCase):
 
     def test__init(self):
-        tp_config = {'traffic_profile': {'duration': 15}}
+        tp_config = {'traffic_profile': {'packet_sizes': {'64B': 100}}}
         tp_config_obj = base.TrafficProfileConfig(tp_config)
-        self.assertEqual(15, tp_config_obj.duration)
+        self.assertEqual({'64B': 100}, tp_config_obj.packet_sizes)
+        self.assertEqual(base.TrafficProfileConfig.DEFAULT_SCHEMA,
+                         tp_config_obj.schema)
+        self.assertEqual(base.TrafficProfileConfig.DEFAULT_FRAME_RATE,
+                         tp_config_obj.frame_rate)
+        self.assertEqual(base.TrafficProfileConfig.DEFAULT_DURATION,
+                         tp_config_obj.duration)
diff --git a/yardstick/tests/unit/network_services/traffic_profile/test_rfc2544.py b/yardstick/tests/unit/network_services/traffic_profile/test_rfc2544.py
index 2684e0ba1..0cf93f9ae 100644
--- a/yardstick/tests/unit/network_services/traffic_profile/test_rfc2544.py
+++ b/yardstick/tests/unit/network_services/traffic_profile/test_rfc2544.py
@@ -11,33 +11,26 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-#
 
-import unittest
 import mock
 
-from yardstick.tests import STL_MOCKS
-
+from trex_stl_lib import api as Pkt
+from trex_stl_lib import trex_stl_client
+from trex_stl_lib import trex_stl_packet_builder_scapy
+from trex_stl_lib import trex_stl_streams
 
-STLClient = mock.MagicMock()
-stl_patch = mock.patch.dict("sys.modules", STL_MOCKS)
-stl_patch.start()
+from yardstick.network_services.traffic_profile import rfc2544
+from yardstick.tests.unit import base
 
-if stl_patch:
-    from yardstick.network_services.traffic_profile.trex_traffic_profile \
-        import TrexProfile
-    from yardstick.network_services.traffic_profile.rfc2544 import \
-        RFC2544Profile
 
-
-class TestRFC2544Profile(unittest.TestCase):
+class TestRFC2544Profile(base.BaseUnitTestCase):
     TRAFFIC_PROFILE = {
         "schema": "isb:traffic_profile:0.1",
         "name": "fixed",
         "description": "Fixed traffic profile to run UDP traffic",
         "traffic_profile": {
             "traffic_type": "FixedTraffic",
-            "frame_rate": 100,  # pps
+            "frame_rate": 100,
             "flow_number": 10,
             "frame_size": 64}}
 
@@ -45,233 +38,251 @@ class TestRFC2544Profile(unittest.TestCase):
                'name': 'rfc2544',
                'traffic_profile': {'traffic_type': 'RFC2544Profile',
                                    'frame_rate': 100},
-               'downlink_0': {'ipv4':
-                              {'outer_l2': {'framesize':
-                                            {'64B': '100', '1518B': '0',
-                                             '128B': '0', '1400B': '0',
-                                             '256B': '0', '373b': '0',
-                                             '570B': '0'}},
-                               'outer_l3v4': {'dstip4': '1.1.1.1-1.15.255.255',
-                                              'proto': 'udp',
-                                              'srcip4': '90.90.1.1-90.105.255.255',
-                                              'dscp': 0, 'ttl': 32, 'count': 1},
-                               'outer_l4': {'srcport': '2001',
-                                            'dsrport': '1234', 'count': 1}}},
-               'uplink_0': {'ipv4':
-                            {'outer_l2': {'framesize':
-                                          {'64B': '100', '1518B': '0',
-                                           '128B': '0', '1400B': '0',
-                                           '256B': '0', '373b': '0',
-                                           '570B': '0'}},
-                             'outer_l3v4': {'dstip4': '9.9.1.1-90.105.255.255',
-                                            'proto': 'udp',
-                                            'srcip4': '1.1.1.1-1.15.255.255',
-                                            'dscp': 0, 'ttl': 32, 'count': 1},
-                             'outer_l4': {'dstport': '2001',
-                                          'srcport': '1234', 'count': 1}}},
+               'downlink_0':
+                   {'ipv4':
+                        {'outer_l2':
+                             {'framesize':
+                                  {'64B': '100', '1518B': '0',
+                                   '128B': '0', '1400B': '0',
+                                   '256B': '0', '373b': '0',
+                                   '570B': '0'}},
+                         'outer_l3v4':
+                             {'dstip4': '1.1.1.1-1.15.255.255',
+                              'proto': 'udp',
+                              'srcip4': '90.90.1.1-90.105.255.255',
+                              'dscp': 0, 'ttl': 32, 'count': 1},
+                         'outer_l4':
+                             {'srcport': '2001',
+                              'dsrport': '1234', 'count': 1}}},
+               'uplink_0':
+                   {'ipv4':
+                        {'outer_l2':
+                             {'framesize':
+                                  {'64B': '100', '1518B': '0',
+                                   '128B': '0', '1400B': '0',
+                                   '256B': '0', '373b': '0',
+                                   '570B': '0'}},
+                         'outer_l3v4':
+                             {'dstip4': '9.9.1.1-90.105.255.255',
+                              'proto': 'udp',
+                              'srcip4': '1.1.1.1-1.15.255.255',
+                              'dscp': 0, 'ttl': 32, 'count': 1},
+                         'outer_l4':
+                             {'dstport': '2001',
+                              'srcport': '1234', 'count': 1}}},
                'schema': 'isb:traffic_profile:0.1'}
 
     def test___init__(self):
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        self.assertIsNotNone(r_f_c2544_profile.rate)
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        self.assertEqual(rfc2544_profile.max_rate, rfc2544_profile.rate)
+        self.assertEqual(0, rfc2544_profile.min_rate)
 
-    def test_execute(self):
-        traffic_generator = mock.Mock(autospec=TrexProfile)
-        traffic_generator.networks = {
-            "uplink_0": ["xe0"],
-            "downlink_0": ["xe1"],
-        }
-        traffic_generator.client.return_value = True
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile.params = self.PROFILE
-        r_f_c2544_profile.first_run = True
-        self.assertIsNone(r_f_c2544_profile.execute_traffic(traffic_generator))
+    def test_stop_traffic(self):
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        mock_generator = mock.Mock()
+        rfc2544_profile.stop_traffic(traffic_generator=mock_generator)
+        mock_generator.client.stop.assert_called_once()
+        mock_generator.client.reset.assert_called_once()
+        mock_generator.client.remove_all_streams.assert_called_once()
 
-    def test_get_drop_percentage(self):
-        traffic_generator = mock.Mock(autospec=TrexProfile)
-        traffic_generator.networks = {
-            "uplink_0": ["xe0"],
-            "downlink_0": ["xe1"],
-        }
-        traffic_generator.client.return_value = True
+    def test_execute_traffic(self):
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        mock_generator = mock.Mock()
+        mock_generator.networks = {
+            'downlink_0': ['xe0', 'xe1'],
+            'uplink_0': ['xe2', 'xe3'],
+            'downlink_1': []}
+        mock_generator.port_num.side_effect = [10, 20, 30, 40]
+        mock_generator.rfc2544_helper.correlated_traffic = False
+        rfc2544_profile.params = {
+            'downlink_0': 'profile1',
+            'uplink_0': 'profile2'}
 
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile.params = self.PROFILE
-        r_f_c2544_profile.register_generator(traffic_generator)
-        self.assertIsNone(r_f_c2544_profile.execute_traffic(traffic_generator))
+        with mock.patch.object(rfc2544_profile, '_create_profile') as \
+                mock_create_profile:
+            rfc2544_profile.execute_traffic(traffic_generator=mock_generator)
+        mock_create_profile.assert_has_calls([
+            mock.call('profile1', rfc2544_profile.rate, mock.ANY),
+            mock.call('profile1', rfc2544_profile.rate, mock.ANY),
+            mock.call('profile2', rfc2544_profile.rate, mock.ANY),
+            mock.call('profile2', rfc2544_profile.rate, mock.ANY)])
+        mock_generator.client.add_streams.assert_has_calls([
+            mock.call(mock.ANY, ports=[10]),
+            mock.call(mock.ANY, ports=[20]),
+            mock.call(mock.ANY, ports=[30]),
+            mock.call(mock.ANY, ports=[40])])
+        mock_generator.client.start(ports=[10, 20, 30, 40],
+                                    duration=rfc2544_profile.config.duration,
+                                    force=True)
 
-        samples = {}
-        for ifname in range(1):
-            name = "xe{}".format(ifname)
-            samples[name] = {
-                "rx_throughput_fps": 20,
-                "tx_throughput_fps": 20,
-                "rx_throughput_mbps": 10,
-                "tx_throughput_mbps": 10,
-                "in_packets": 1000,
-                "out_packets": 1000,
-            }
+    @mock.patch.object(trex_stl_streams, 'STLProfile')
+    def test__create_profile(self, mock_stl_profile):
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        port_pg_id = mock.ANY
+        profile_data = {'packetid_1': {'outer_l2': {'framesize': 'imix_info'}}}
+        rate = 100
+        with mock.patch.object(rfc2544_profile, '_create_imix_data') as \
+                mock_create_imix, \
+                mock.patch.object(rfc2544_profile, '_create_vm') as \
+                mock_create_vm, \
+                mock.patch.object(rfc2544_profile, '_create_streams') as \
+                mock_create_streams:
+            mock_create_imix.return_value = 'imix_data'
+            mock_create_streams.return_value = ['stream1']
+            rfc2544_profile._create_profile(profile_data, rate, port_pg_id)
 
-        expected = {
-            'DropPercentage': 0.0,
-            'RxThroughput': 100 / 3.0,
-            'TxThroughput': 100 / 3.0,
-            'CurrentDropPercentage': 0.0,
-            'Throughput': 66.66666666666667,
-            'xe0': {
-                'tx_throughput_fps': 20,
-                'in_packets': 1000,
-                'out_packets': 1000,
-                'rx_throughput_mbps': 10,
-                'tx_throughput_mbps': 10,
-                'rx_throughput_fps': 20,
-            },
-        }
-        traffic_generator.generate_samples.return_value = samples
-        traffic_generator.RUN_DURATION = 30
-        traffic_generator.rfc2544_helper.tolerance_low = 0.0001
-        traffic_generator.rfc2544_helper.tolerance_high = 0.0001
-        result = r_f_c2544_profile.get_drop_percentage(traffic_generator)
-        self.assertDictEqual(result, expected)
+        mock_create_imix.assert_called_once_with('imix_info')
+        mock_create_vm.assert_called_once_with(
+            {'outer_l2': {'framesize': 'imix_info'}})
+        mock_create_streams.assert_called_once_with('imix_data', 100,
+                                                    port_pg_id)
+        mock_stl_profile.assert_called_once_with(['stream1'])
 
-    def test_get_drop_percentage_update(self):
-        traffic_generator = mock.Mock(autospec=RFC2544Profile)
-        traffic_generator.networks = {
-            "uplink_0": ["xe0"],
-            "downlink_0": ["xe1"],
-        }
-        traffic_generator.client = mock.Mock(return_value=True)
+    def test__create_imix_data(self):
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        data = {'64B': 50, '128B': 50}
+        self.assertEqual({'64': 50.0, '128': 50.0},
+                         rfc2544_profile._create_imix_data(data))
+        data = {'64B': 1, '128b': 3}
+        self.assertEqual({'64': 25.0, '128': 75.0},
+                         rfc2544_profile._create_imix_data(data))
+        data = {}
+        self.assertEqual({}, rfc2544_profile._create_imix_data(data))
 
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile.params = self.PROFILE
-        r_f_c2544_profile.register_generator(traffic_generator)
-        self.assertIsNone(r_f_c2544_profile.execute_traffic())
+    def test__create_vm(self):
+        packet = {'outer_l2': 'l2_definition'}
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        with mock.patch.object(rfc2544_profile, '_set_outer_l2_fields') as \
+                mock_l2_fileds:
+            rfc2544_profile._create_vm(packet)
+        mock_l2_fileds.assert_called_once_with('l2_definition')
 
-        samples = {}
-        for ifname in range(1):
-            name = "xe{}".format(ifname)
-            samples[name] = {
-                "rx_throughput_fps": 20,
-                "tx_throughput_fps": 20,
-                "rx_throughput_mbps": 10,
-                "tx_throughput_mbps": 10,
-                "in_packets": 1000,
-                "out_packets": 1002,
-            }
-        expected = {
-            'DropPercentage': 0.1996,
-            'RxThroughput': 33.333333333333336,
-            'TxThroughput': 33.4,
-            'CurrentDropPercentage': 0.1996,
-            'Throughput': 66.66666666666667,
-            'xe0': {
-                'tx_throughput_fps': 20,
-                'in_packets': 1000,
-                'out_packets': 1002,
-                'rx_throughput_mbps': 10,
-                'tx_throughput_mbps': 10,
-                'rx_throughput_fps': 20,
-            },
-        }
-        traffic_generator.generate_samples = mock.MagicMock(
-            return_value=samples)
-        traffic_generator.RUN_DURATION = 30
-        traffic_generator.rfc2544_helper.tolerance_low = 0.0001
-        traffic_generator.rfc2544_helper.tolerance_high = 0.0001
-        result = r_f_c2544_profile.get_drop_percentage(traffic_generator)
-        self.assertDictEqual(expected, result)
+    @mock.patch.object(trex_stl_packet_builder_scapy, 'STLPktBuilder',
+                       return_value='packet')
+    def test__create_single_packet(self, mock_pktbuilder):
+        size = 128
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        rfc2544_profile.ether_packet = Pkt.Eth()
+        rfc2544_profile.ip_packet = Pkt.IP()
+        rfc2544_profile.udp_packet = Pkt.UDP()
+        rfc2544_profile.trex_vm = 'trex_vm'
+        base_pkt = (rfc2544_profile.ether_packet / rfc2544_profile.ip_packet /
+                    rfc2544_profile.udp_packet)
+        pad = (size - len(base_pkt)) * 'x'
+        output = rfc2544_profile._create_single_packet(size=size)
+        mock_pktbuilder.assert_called_once_with(pkt=base_pkt / pad,
+                                                vm='trex_vm')
+        self.assertEqual(output, 'packet')
 
-    def test_get_drop_percentage_div_zero(self):
-        traffic_generator = mock.Mock(autospec=TrexProfile)
-        traffic_generator.networks = {
-            "uplink_0": ["xe0"],
-            "downlink_0": ["xe1"],
-        }
-        traffic_generator.client = \
-            mock.Mock(return_value=True)
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile.params = self.PROFILE
-        self.assertIsNone(
-            r_f_c2544_profile.execute_traffic(traffic_generator))
-        samples = {}
-        for ifname in range(1):
-            name = "xe{}".format(ifname)
-            samples[name] = {"rx_throughput_fps": 20,
-                             "tx_throughput_fps": 20,
-                             "rx_throughput_mbps": 10,
-                             "tx_throughput_mbps": 10,
-                             "in_packets": 1000,
-                             "out_packets": 0}
-        r_f_c2544_profile.throughput_max = 0
-        expected = {
-            'DropPercentage': 100.0, 'RxThroughput': 100 / 3.0,
-            'TxThroughput': 0.0, 'CurrentDropPercentage': 100.0,
-            'Throughput': 66.66666666666667,
-            'xe0': {
-                'tx_throughput_fps': 20, 'in_packets': 1000,
-                'out_packets': 0, 'rx_throughput_mbps': 10,
-                'tx_throughput_mbps': 10, 'rx_throughput_fps': 20
-            }
-        }
-        traffic_generator.generate_samples = mock.Mock(return_value=samples)
-        traffic_generator.RUN_DURATION = 30
-        traffic_generator.rfc2544_helper.tolerance_low = 0.0001
-        traffic_generator.rfc2544_helper.tolerance_high = 0.0001
-        self.assertDictEqual(expected,
-                             r_f_c2544_profile.get_drop_percentage(traffic_generator))
+    @mock.patch.object(trex_stl_packet_builder_scapy, 'STLPktBuilder',
+                       return_value='packet')
+    def test__create_single_packet_qinq(self, mock_pktbuilder):
+        size = 128
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        rfc2544_profile.ether_packet = Pkt.Eth()
+        rfc2544_profile.ip_packet = Pkt.IP()
+        rfc2544_profile.udp_packet = Pkt.UDP()
+        rfc2544_profile.trex_vm = 'trex_vm'
+        rfc2544_profile.qinq = True
+        rfc2544_profile.qinq_packet = Pkt.Dot1Q(vlan=1) / Pkt.Dot1Q(vlan=2)
+        base_pkt = (rfc2544_profile.ether_packet /
+                    rfc2544_profile.qinq_packet / rfc2544_profile.ip_packet /
+                    rfc2544_profile.udp_packet)
+        pad = (size - len(base_pkt)) * 'x'
+        output = rfc2544_profile._create_single_packet(size=size)
+        mock_pktbuilder.assert_called_once_with(pkt=base_pkt / pad,
+                                                vm='trex_vm')
+        self.assertEqual(output, 'packet')
+
+    @mock.patch.object(trex_stl_streams, 'STLFlowLatencyStats')
+    @mock.patch.object(trex_stl_streams, 'STLTXCont')
+    @mock.patch.object(trex_stl_client, 'STLStream')
+    def test__create_streams(self, mock_stream, mock_txcont, mock_latency):
+        imix_data = {'64': 25, '512': 75}
+        rate = 35
+        port_pg_id = rfc2544.PortPgIDMap()
+        port_pg_id.add_port(10)
+        mock_stream.side_effect = ['stream1', 'stream2']
+        mock_txcont.side_effect = ['txcont1', 'txcont2']
+        mock_latency.side_effect = ['latency1', 'latency2']
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        with mock.patch.object(rfc2544_profile, '_create_single_packet'):
+            output = rfc2544_profile._create_streams(imix_data, rate,
+                                                     port_pg_id)
+        self.assertEqual(['stream1', 'stream2'], output)
+        mock_latency.assert_has_calls([
+            mock.call(pg_id=1), mock.call(pg_id=2)])
+        mock_txcont.assert_has_calls([
+            mock.call(percentage=float(25 * 35) / 100),
+            mock.call(percentage=float(75 * 35) / 100)], any_order=True)
+
+    def test_get_drop_percentage(self):
+        rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
+        samples = [
+            {'xe1': {'tx_throughput_fps': 100,
+                     'rx_throughput_fps': 101,
+                     'out_packets': 2000,
+                     'in_packets': 2010},
+             'xe2': {'tx_throughput_fps': 200,
+                     'rx_throughput_fps': 201,
+                     'out_packets': 4000,
+                     'in_packets': 4010}},
+            {'xe1': {'tx_throughput_fps': 106,
+                     'rx_throughput_fps': 108,
+                     'out_packets': 2031,
+                     'in_packets': 2040,
+                     'latency': 'Latency1'},
+             'xe2': {'tx_throughput_fps': 203,
+                     'rx_throughput_fps': 215,
+                     'out_packets': 4025,
+                     'in_packets': 4040,
+                     'latency': 'Latency2'}}
+        ]
+        output = rfc2544_profile.get_drop_percentage(samples, 0, 0, False)
+        expected = {'DropPercentage': 0.3963,
+                    'Latency': {'xe1': 'Latency1', 'xe2': 'Latency2'},
+                    'RxThroughput': 312.5,
+                    'TxThroughput': 304.5,
+                    'CurrentDropPercentage': 0.3963,
+                    'Rate': 100,
+                    'Throughput': 312.5}
+        self.assertEqual(expected, output)
 
-    def test_get_multiplier(self):
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile.max_rate = 100
-        r_f_c2544_profile.min_rate = 100
-        self.assertEqual("1.0", r_f_c2544_profile.get_multiplier())
 
-    def test_calculate_pps(self):
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile.rate = 100
-        r_f_c2544_profile.pps = 100
-        samples = {'Throughput': 4549093.33}
-        self.assertEqual((2274546.67, 1.0),
-                         r_f_c2544_profile.calculate_pps(samples))
+class PortPgIDMapTestCase(base.BaseUnitTestCase):
 
-    def test_create_single_stream(self):
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile._create_single_packet = mock.MagicMock()
-        r_f_c2544_profile.pg_id = 1
-        self.assertIsNotNone(
-            r_f_c2544_profile.create_single_stream(64, 2274546.67))
+    def test_add_port(self):
+        port_pg_id_map = rfc2544.PortPgIDMap()
+        port_pg_id_map.add_port(10)
+        self.assertEqual(10, port_pg_id_map._last_port)
+        self.assertEqual([], port_pg_id_map._port_pg_id_map[10])
 
-    def test_create_single_stream_no_pg_id(self):
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile._create_single_packet = mock.MagicMock()
-        r_f_c2544_profile.pg_id = 0
-        self.assertIsNotNone(
-            r_f_c2544_profile.create_single_stream(64, 2274546.67))
+    def test_get_pg_ids(self):
+        port_pg_id_map = rfc2544.PortPgIDMap()
+        port_pg_id_map.add_port(10)
+        port_pg_id_map.increase_pg_id()
+        port_pg_id_map.increase_pg_id()
+        port_pg_id_map.add_port(20)
+        port_pg_id_map.increase_pg_id()
+        self.assertEqual([1, 2], port_pg_id_map.get_pg_ids(10))
+        self.assertEqual([3], port_pg_id_map.get_pg_ids(20))
 
-    def test_execute_latency(self):
-        traffic_generator = mock.Mock(autospec=TrexProfile)
-        traffic_generator.networks = {
-            "private_0": ["xe0"],
-            "public_0": ["xe1"],
-        }
-        traffic_generator.client = \
-            mock.Mock(return_value=True)
-        r_f_c2544_profile = RFC2544Profile(self.TRAFFIC_PROFILE)
-        r_f_c2544_profile.params = self.PROFILE
-        r_f_c2544_profile.first_run = True
-        samples = {}
-        for ifname in range(1):
-            name = "xe{}".format(ifname)
-            samples[name] = {"rx_throughput_fps": 20,
-                             "tx_throughput_fps": 20,
-                             "rx_throughput_mbps": 10,
-                             "tx_throughput_mbps": 10,
-                             "in_packets": 1000,
-                             "out_packets": 0}
+    def test_increase_pg_id_no_port(self):
+        port_pg_id_map = rfc2544.PortPgIDMap()
+        self.assertIsNone(port_pg_id_map.increase_pg_id())
 
-        samples['Throughput'] = 4549093.33
-        r_f_c2544_profile.calculate_pps = mock.Mock(return_value=[2274546.67,
-                                                                  1.0])
+    def test_increase_pg_id_last_port(self):
+        port_pg_id_map = rfc2544.PortPgIDMap()
+        port_pg_id_map.add_port(10)
+        self.assertEqual(1, port_pg_id_map.increase_pg_id())
+        self.assertEqual([1], port_pg_id_map.get_pg_ids(10))
+        self.assertEqual(10, port_pg_id_map._last_port)
 
-        self.assertIsNone(r_f_c2544_profile.execute_latency(traffic_generator,
-                                                            samples))
+    def test_increase_pg_id(self):
+        port_pg_id_map = rfc2544.PortPgIDMap()
+        port_pg_id_map.add_port(10)
+        port_pg_id_map.increase_pg_id()
+        self.assertEqual(2, port_pg_id_map.increase_pg_id(port=20))
+        self.assertEqual([1], port_pg_id_map.get_pg_ids(10))
+        self.assertEqual([2], port_pg_id_map.get_pg_ids(20))
+        self.assertEqual(20, port_pg_id_map._last_port)
diff --git a/yardstick/tests/unit/network_services/traffic_profile/test_trex_traffic_profile.py b/yardstick/tests/unit/network_services/traffic_profile/test_trex_traffic_profile.py
index 34face774..628e85459 100644
--- a/yardstick/tests/unit/network_services/traffic_profile/test_trex_traffic_profile.py
+++ b/yardstick/tests/unit/network_services/traffic_profile/test_trex_traffic_profile.py
@@ -14,29 +14,12 @@
 
 import ipaddress
 
-import mock
 import six
 import unittest
 
 from yardstick.common import exceptions as y_exc
-from yardstick.tests import STL_MOCKS
-
-STLClient = mock.MagicMock()
-stl_patch = mock.patch.dict("sys.modules", STL_MOCKS)
-stl_patch.start()
-
-if stl_patch:
-    from yardstick.network_services.traffic_profile.base import TrafficProfile
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import TrexProfile
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import SRC
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import DST
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import ETHERNET
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import IP
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import IPv6
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import UDP
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import SRC_PORT
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import DST_PORT
-    from yardstick.network_services.traffic_profile.trex_traffic_profile import TYPE_OF_SERVICE
+from yardstick.network_services.traffic_profile import base as tp_base
+from yardstick.network_services.traffic_profile import trex_traffic_profile
 
 
 class TestTrexProfile(unittest.TestCase):
@@ -59,7 +42,7 @@ class TestTrexProfile(unittest.TestCase):
         'name': 'rfc2544',
         'traffic_profile': {'traffic_type': 'RFC2544Profile',
                             'frame_rate': 100},
-        TrafficProfile.DOWNLINK: {
+        tp_base.TrafficProfile.DOWNLINK: {
             'ipv4': {'outer_l2': {'framesize': {'64B': '100',
                                                 '1518B': '0',
                                                 '128B': '0',
@@ -77,7 +60,7 @@ class TestTrexProfile(unittest.TestCase):
                      'outer_l4': {'srcport': '2001',
                                   'dsrport': '1234',
                                   'count': 1}}},
-        TrafficProfile.UPLINK: {
+        tp_base.TrafficProfile.UPLINK: {
             'ipv4':
                 {'outer_l2': {'framesize':
                                   {'64B': '100', '1518B': '0',
@@ -99,7 +82,7 @@ class TestTrexProfile(unittest.TestCase):
         'name': 'rfc2544',
         'traffic_profile': {'traffic_type': 'RFC2544Profile',
                             'frame_rate': 100},
-        TrafficProfile.DOWNLINK: {
+        tp_base.TrafficProfile.DOWNLINK: {
             'ipv6': {'outer_l2': {'framesize':
                                       {'64B': '100', '1518B': '0',
                                        '128B': '0', '1400B': '0',
@@ -118,7 +101,7 @@ class TestTrexProfile(unittest.TestCase):
                      'outer_l4': {'srcport': '2001',
                                   'dsrport': '1234',
                                   'count': 1}}},
-        TrafficProfile.UPLINK: {
+        tp_base.TrafficProfile.UPLINK: {
             'ipv6': {'outer_l2': {'framesize':
                                       {'64B': '100', '1518B': '0',
                                        '128B': '0', '1400B': '0',
@@ -139,66 +122,56 @@ class TestTrexProfile(unittest.TestCase):
                                   'count': 1}}},
         'schema': 'isb:traffic_profile:0.1'}
 
-    def setUp(self):
-        self.trex_profile = TrexProfile(self.PROFILE)
-
     def test___init__(self):
-        self.assertEqual(self.trex_profile.pps, 100)
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
+        self.assertEqual(trex_profile.pps, 100)
 
     def test_qinq(self):
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
         qinq = {"S-VLAN": {"id": 128, "priority": 0, "cfi": 0},
                 "C-VLAN": {"id": 512, "priority": 0, "cfi": 0}}
 
-        self.assertIsNone(self.trex_profile.set_qinq(qinq))
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
+        self.assertIsNone(trex_profile.set_qinq(qinq))
 
         qinq = {"S-VLAN": {"id": "128-130", "priority": 0, "cfi": 0},
                 "C-VLAN": {"id": "512-515", "priority": 0, "cfi": 0}}
-        self.assertIsNone(self.trex_profile.set_qinq(qinq))
+        self.assertIsNone(trex_profile.set_qinq(qinq))
 
     def test__set_outer_l2_fields(self):
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
         qinq = {"S-VLAN": {"id": 128, "priority": 0, "cfi": 0},
                 "C-VLAN": {"id": 512, "priority": 0, "cfi": 0}}
-        outer_l2 = self.PROFILE[TrafficProfile.UPLINK]['ipv4']['outer_l2']
+        outer_l2 = self.PROFILE[
+            tp_base.TrafficProfile.UPLINK]['ipv4']['outer_l2']
         outer_l2['QinQ'] = qinq
-        self.assertIsNone(self.trex_profile._set_outer_l2_fields(outer_l2))
+        self.assertIsNone(trex_profile._set_outer_l2_fields(outer_l2))
 
     def test__set_outer_l3v4_fields(self):
-        outer_l3v4 = self.PROFILE[TrafficProfile.UPLINK]['ipv4']['outer_l3v4']
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
+        outer_l3v4 = self.PROFILE[
+            tp_base.TrafficProfile.UPLINK]['ipv4']['outer_l3v4']
         outer_l3v4['proto'] = 'tcp'
-        self.assertIsNone(self.trex_profile._set_outer_l3v4_fields(outer_l3v4))
+        self.assertIsNone(trex_profile._set_outer_l3v4_fields(outer_l3v4))
 
     def test__set_outer_l3v6_fields(self):
-        outer_l3v6 = self.PROFILE_v6[TrafficProfile.UPLINK]['ipv6']['outer_l3v4']
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
+        outer_l3v6 = self.PROFILE_v6[
+            tp_base.TrafficProfile.UPLINK]['ipv6']['outer_l3v4']
         outer_l3v6['proto'] = 'tcp'
         outer_l3v6['tc'] = 1
         outer_l3v6['hlim'] = 10
-        self.assertIsNone(self.trex_profile._set_outer_l3v6_fields(outer_l3v6))
+        self.assertIsNone(trex_profile._set_outer_l3v6_fields(outer_l3v6))
 
     def test__set_outer_l4_fields(self):
-        outer_l4 = self.PROFILE[TrafficProfile.UPLINK]['ipv4']['outer_l4']
-        self.assertIsNone(self.trex_profile._set_outer_l4_fields(outer_l4))
-
-    def test_get_streams(self):
-        profile_data = self.PROFILE[TrafficProfile.UPLINK]
-        self.assertIsNotNone(self.trex_profile.get_streams(profile_data))
-        self.trex_profile.pg_id = 1
-        self.assertIsNotNone(self.trex_profile.get_streams(profile_data))
-        self.trex_profile.params = self.PROFILE_v6
-        self.trex_profile.profile_data = self.PROFILE_v6[TrafficProfile.UPLINK]
-        self.assertIsNotNone(self.trex_profile.get_streams(profile_data))
-        self.trex_profile.pg_id = 1
-        self.assertIsNotNone(self.trex_profile.get_streams(profile_data))
-
-    def test_generate_packets(self):
-        self.trex_profile.fsize = 10
-        self.trex_profile.base_pkt = [10]
-        self.assertIsNone(self.trex_profile.generate_packets())
-
-    def test_generate_imix_data_error(self):
-        self.assertEqual({}, self.trex_profile.generate_imix_data(False))
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
+        outer_l4 = self.PROFILE[
+            tp_base.TrafficProfile.UPLINK]['ipv4']['outer_l4']
+        self.assertIsNone(trex_profile._set_outer_l4_fields(outer_l4))
 
     def test__count_ip_ipv4(self):
-        start, end, count = TrexProfile._count_ip('1.1.1.1', '1.2.3.4')
+        start, end, count = trex_traffic_profile.TrexProfile._count_ip(
+            '1.1.1.1', '1.2.3.4')
         self.assertEqual('1.1.1.1', str(start))
         self.assertEqual('1.2.3.4', str(end))
         diff = (int(ipaddress.IPv4Address(six.u('1.2.3.4'))) -
@@ -208,7 +181,8 @@ class TestTrexProfile(unittest.TestCase):
     def test__count_ip_ipv6(self):
         start_ip = '0064:ff9b:0:0:0:0:9810:6414'
         end_ip = '0064:ff9b:0:0:0:0:9810:6420'
-        start, end, count = TrexProfile._count_ip(start_ip, end_ip)
+        start, end, count = trex_traffic_profile.TrexProfile._count_ip(
+            start_ip, end_ip)
         self.assertEqual(0x98106414, start)
         self.assertEqual(0x98106420, end)
         self.assertEqual(0x98106420 - 0x98106414, count)
@@ -217,10 +191,10 @@ class TestTrexProfile(unittest.TestCase):
         start_ip = '0064:ff9b:0:0:0:0:9810:6420'
         end_ip = '0064:ff9b:0:0:0:0:9810:6414'
         with self.assertRaises(y_exc.IPv6RangeError):
-            TrexProfile._count_ip(start_ip, end_ip)
+            trex_traffic_profile.TrexProfile._count_ip(start_ip, end_ip)
 
     def test__dscp_range_action_partial_actual_count_zero(self):
-        traffic_profile = TrexProfile(self.PROFILE)
+        traffic_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
         dscp_partial = traffic_profile._dscp_range_action_partial()
 
         flow_vars_initial_length = len(traffic_profile.vm_flow_vars)
@@ -228,7 +202,7 @@ class TestTrexProfile(unittest.TestCase):
         self.assertEqual(len(traffic_profile.vm_flow_vars), flow_vars_initial_length + 2)
 
     def test__dscp_range_action_partial_count_greater_than_actual(self):
-        traffic_profile = TrexProfile(self.PROFILE)
+        traffic_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
         dscp_partial = traffic_profile._dscp_range_action_partial()
 
         flow_vars_initial_length = len(traffic_profile.vm_flow_vars)
@@ -236,7 +210,7 @@ class TestTrexProfile(unittest.TestCase):
         self.assertEqual(len(traffic_profile.vm_flow_vars), flow_vars_initial_length + 2)
 
     def test__udp_range_action_partial_actual_count_zero(self):
-        traffic_profile = TrexProfile(self.PROFILE)
+        traffic_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
         traffic_profile.udp['field1'] = 'value1'
         udp_partial = traffic_profile._udp_range_action_partial('field1')
 
@@ -245,46 +219,59 @@ class TestTrexProfile(unittest.TestCase):
         self.assertEqual(len(traffic_profile.vm_flow_vars), flow_vars_initial_length + 2)
 
     def test__udp_range_action_partial_count_greater_than_actual(self):
-        traffic_profile = TrexProfile(self.PROFILE)
+        traffic_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
         traffic_profile.udp['field1'] = 'value1'
-        udp_partial = traffic_profile._udp_range_action_partial('field1', 'not_used_count')
-
+        udp_partial = traffic_profile._udp_range_action_partial(
+            'field1', 'not_used_count')
         flow_vars_initial_length = len(traffic_profile.vm_flow_vars)
         udp_partial('1', '10', '100')
         self.assertEqual(len(traffic_profile.vm_flow_vars), flow_vars_initial_length + 2)
 
     def test__general_single_action_partial(self):
-        self.trex_profile._general_single_action_partial(ETHERNET)(SRC)(
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
+        trex_profile._general_single_action_partial(
+            trex_traffic_profile.ETHERNET)(trex_traffic_profile.SRC)(
             self.EXAMPLE_ETHERNET_ADDR)
         self.assertEqual(self.EXAMPLE_ETHERNET_ADDR,
-                         self.trex_profile.ether_packet.src)
+                         trex_profile.ether_packet.src)
 
-        self.trex_profile._general_single_action_partial(IP)(DST)(
-            self.EXAMPLE_IP_ADDR)
-        self.assertEqual(self.EXAMPLE_IP_ADDR, self.trex_profile.ip_packet.dst)
+        trex_profile._general_single_action_partial(trex_traffic_profile.IP)(
+            trex_traffic_profile.DST)(self.EXAMPLE_IP_ADDR)
+        self.assertEqual(self.EXAMPLE_IP_ADDR, trex_profile.ip_packet.dst)
 
-        self.trex_profile._general_single_action_partial(IPv6)(DST)(
-            self.EXAMPLE_IPv6_ADDR)
-        self.assertEqual(self.EXAMPLE_IPv6_ADDR,
-                         self.trex_profile.ip6_packet.dst)
+        trex_profile._general_single_action_partial(trex_traffic_profile.IPv6)(
+            trex_traffic_profile.DST)(self.EXAMPLE_IPv6_ADDR)
+        self.assertEqual(self.EXAMPLE_IPv6_ADDR, trex_profile.ip6_packet.dst)
 
-        self.trex_profile._general_single_action_partial(UDP)(SRC_PORT)(5060)
-        self.assertEqual(5060, self.trex_profile.udp_packet.sport)
+        trex_profile._general_single_action_partial(trex_traffic_profile.UDP)(
+            trex_traffic_profile.SRC_PORT)(5060)
+        self.assertEqual(5060, trex_profile.udp_packet.sport)
 
-        self.trex_profile._general_single_action_partial(
-            IP)(TYPE_OF_SERVICE)(0)
-        self.assertEqual(0, self.trex_profile.ip_packet.tos)
+        trex_profile._general_single_action_partial(trex_traffic_profile.IP)(
+            trex_traffic_profile.TYPE_OF_SERVICE)(0)
+        self.assertEqual(0, trex_profile.ip_packet.tos)
 
     def test__set_proto_addr(self):
+        trex_profile = trex_traffic_profile.TrexProfile(self.PROFILE)
+
         ether_range = "00:00:00:00:00:01-00:00:00:00:00:02"
         ip_range = "1.1.1.2-1.1.1.10"
         ipv6_range = '0064:ff9b:0:0:0:0:9810:6414-0064:ff9b:0:0:0:0:9810:6420'
 
-        self.trex_profile._set_proto_addr(ETHERNET, SRC, ether_range)
-        self.trex_profile._set_proto_addr(ETHERNET, DST, ether_range)
-        self.trex_profile._set_proto_addr(IP, SRC, ip_range)
-        self.trex_profile._set_proto_addr(IP, DST, ip_range)
-        self.trex_profile._set_proto_addr(IPv6, SRC, ipv6_range)
-        self.trex_profile._set_proto_addr(IPv6, DST, ipv6_range)
-        self.trex_profile._set_proto_addr(UDP, SRC_PORT, '5060-5090')
-        self.trex_profile._set_proto_addr(UDP, DST_PORT, '5060')
+        trex_profile._set_proto_addr(trex_traffic_profile.ETHERNET,
+                                     trex_traffic_profile.SRC, ether_range)
+        trex_profile._set_proto_addr(trex_traffic_profile.ETHERNET,
+                                     trex_traffic_profile.DST, ether_range)
+        trex_profile._set_proto_addr(trex_traffic_profile.IP,
+                                     trex_traffic_profile.SRC, ip_range)
+        trex_profile._set_proto_addr(trex_traffic_profile.IP,
+                                     trex_traffic_profile.DST, ip_range)
+        trex_profile._set_proto_addr(trex_traffic_profile.IPv6,
+                                     trex_traffic_profile.SRC, ipv6_range)
+        trex_profile._set_proto_addr(trex_traffic_profile.IPv6,
+                                     trex_traffic_profile.DST, ipv6_range)
+        trex_profile._set_proto_addr(trex_traffic_profile.UDP,
+                                     trex_traffic_profile.SRC_PORT,
+                                     '5060-5090')
+        trex_profile._set_proto_addr(trex_traffic_profile.UDP,
+                                     trex_traffic_profile.DST_PORT, '5060')
diff --git a/yardstick/tests/unit/network_services/vnf_generic/vnf/test_sample_vnf.py b/yardstick/tests/unit/network_services/vnf_generic/vnf/test_sample_vnf.py
index 603f05b97..7c22563e8 100644
--- a/yardstick/tests/unit/network_services/vnf_generic/vnf/test_sample_vnf.py
+++ b/yardstick/tests/unit/network_services/vnf_generic/vnf/test_sample_vnf.py
@@ -11,7 +11,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-#
 
 from copy import deepcopy
 
@@ -19,37 +18,29 @@ import unittest
 import mock
 import six
 
-from yardstick.tests.unit.network_services.vnf_generic.vnf.test_base import mock_ssh
-from yardstick.tests import STL_MOCKS
 from yardstick.benchmark.contexts.base import Context
 from yardstick.common import exceptions as y_exceptions
 from yardstick.common import utils
 from yardstick.network_services.nfvi.resource import ResourceProfile
 from yardstick.network_services.vnf_generic.vnf.base import VnfdHelper
-
-
-class MockError(BaseException):
+from yardstick.network_services.vnf_generic.vnf import sample_vnf
+from yardstick.network_services.vnf_generic.vnf.vnf_ssh_helper import VnfSshHelper
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNFDeployHelper
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import ScenarioHelper
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import ResourceHelper
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import ClientResourceHelper
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import Rfc2544ResourceHelper
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import SetupEnvHelper
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNF
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNFTrafficGen
+from yardstick.network_services.vnf_generic.vnf.sample_vnf import DpdkVnfSetupEnvHelper
+from yardstick.tests.unit.network_services.vnf_generic.vnf import test_base
+
+
+class MockError(Exception):
     pass
 
 
-STLClient = mock.MagicMock()
-stl_patch = mock.patch.dict("sys.modules", STL_MOCKS)
-stl_patch.start()
-
-if stl_patch:
-    from yardstick.network_services.vnf_generic.vnf import sample_vnf
-    from yardstick.network_services.vnf_generic.vnf.vnf_ssh_helper import VnfSshHelper
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNFDeployHelper
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import ScenarioHelper
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import ResourceHelper
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import ClientResourceHelper
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import Rfc2544ResourceHelper
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import SetupEnvHelper
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNF
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNFTrafficGen
-    from yardstick.network_services.vnf_generic.vnf.sample_vnf import DpdkVnfSetupEnvHelper
-
-
 class TestVnfSshHelper(unittest.TestCase):
 
     VNFD_0 = {
@@ -1001,187 +992,52 @@ class TestClientResourceHelper(unittest.TestCase):
     }
 
     @mock.patch('yardstick.network_services.vnf_generic.vnf.sample_vnf.LOG')
-    @mock.patch('yardstick.network_services.vnf_generic.vnf.sample_vnf.STLError',
-                new_callable=lambda: MockError)
-    def test_get_stats_not_connected(self, mock_state_error, *args):
+    @mock.patch.object(sample_vnf, 'STLError', new_callable=lambda: MockError)
+    def test_get_stats_not_connected(self, mock_stl_error, *args):
         vnfd_helper = VnfdHelper(self.VNFD_0)
         ssh_helper = mock.Mock()
         scenario_helper = mock.Mock()
-        dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
+        dpdk_setup_helper = DpdkVnfSetupEnvHelper(
+            vnfd_helper, ssh_helper, scenario_helper)
         client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
-        client_resource_helper.client = mock.MagicMock()
-        client_resource_helper.client.get_stats.side_effect = mock_state_error
+        client_resource_helper.client = mock.Mock()
+        client_resource_helper.client.get_stats.side_effect = mock_stl_error
 
         self.assertEqual(client_resource_helper.get_stats(), {})
         client_resource_helper.client.get_stats.assert_called_once()
 
-    def test_generate_samples(self):
-        vnfd_helper = VnfdHelper(self.VNFD_0)
-        ssh_helper = mock.Mock()
-        scenario_helper = mock.Mock()
-        dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
-        client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
-        client_resource_helper.client = mock.MagicMock()
-        client_resource_helper.client.get_stats.return_value = {
-            0: {
-                'rx_pps': 5.5,
-                'tx_pps': 4.9,
-                'rx_bps': 234.78,
-                'tx_bps': 243.11,
-                'ipackets': 34251,
-                'opackets': 52342,
-            },
-            1: {
-                'tx_pps': 5.9,
-                'rx_bps': 434.78,
-                'opackets': 48791,
-            },
-        }
-
-        expected = {
-            'xe0': {
-                "rx_throughput_fps": 5.5,
-                "tx_throughput_fps": 4.9,
-                "rx_throughput_mbps": 234.78,
-                "tx_throughput_mbps": 243.11,
-                "in_packets": 34251,
-                "out_packets": 52342,
-            },
-            'xe1': {
-                "rx_throughput_fps": 0.0,
-                "tx_throughput_fps": 5.9,
-                "rx_throughput_mbps": 434.78,
-                "tx_throughput_mbps": 0.0,
-                "in_packets": 0,
-                "out_packets": 48791,
-            },
-        }
-        ports = vnfd_helper.port_nums(vnfd_helper.port_pairs.all_ports)
-        result = client_resource_helper.generate_samples(ports)
-        self.assertDictEqual(result, expected)
-
-    def test_generate_samples_with_key(self):
-        vnfd_helper = VnfdHelper(self.VNFD_0)
-        ssh_helper = mock.Mock()
-        scenario_helper = mock.Mock()
-        dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
-        client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
-        client_resource_helper.client = mock.MagicMock()
-        client_resource_helper.client.get_stats.return_value = {
-            'key_name': 'key_value',
-            0: {
-                'rx_pps': 5.5,
-                'tx_pps': 4.9,
-                'rx_bps': 234.78,
-                'tx_bps': 243.11,
-                'ipackets': 34251,
-                'opackets': 52342,
-            },
-            1: {
-                'tx_pps': 5.9,
-                'rx_bps': 434.78,
-                'opackets': 48791,
-            },
-        }
-
-        expected = {
-            'xe0': {
-                'key_name': 'key_value',
-                "rx_throughput_fps": 5.5,
-                "tx_throughput_fps": 4.9,
-                "rx_throughput_mbps": 234.78,
-                "tx_throughput_mbps": 243.11,
-                "in_packets": 34251,
-                "out_packets": 52342,
-            },
-            'xe1': {
-                'key_name': 'key_value',
-                "rx_throughput_fps": 0.0,
-                "tx_throughput_fps": 5.9,
-                "rx_throughput_mbps": 434.78,
-                "tx_throughput_mbps": 0.0,
-                "in_packets": 0,
-                "out_packets": 48791,
-            },
-        }
-        ports = vnfd_helper.port_nums(vnfd_helper.port_pairs.all_ports)
-        result = client_resource_helper.generate_samples(ports, 'key_name')
-        self.assertDictEqual(result, expected)
-
-    def test_generate_samples_with_key_and_default(self):
-        vnfd_helper = VnfdHelper(self.VNFD_0)
-        ssh_helper = mock.Mock()
-        scenario_helper = mock.Mock()
-        dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
-        client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
-        client_resource_helper.client = mock.MagicMock()
-        client_resource_helper.client.get_stats.return_value = {
-            0: {
-                'rx_pps': 5.5,
-                'tx_pps': 4.9,
-                'rx_bps': 234.78,
-                'tx_bps': 243.11,
-                'ipackets': 34251,
-                'opackets': 52342,
-            },
-            1: {
-                'tx_pps': 5.9,
-                'rx_bps': 434.78,
-                'opackets': 48791,
-            },
-        }
-
-        expected = {
-            'xe0': {
-                'key_name': 'default',
-                "rx_throughput_fps": 5.5,
-                "tx_throughput_fps": 4.9,
-                "rx_throughput_mbps": 234.78,
-                "tx_throughput_mbps": 243.11,
-                "in_packets": 34251,
-                "out_packets": 52342,
-            },
-            'xe1': {
-                'key_name': 'default',
-                "rx_throughput_fps": 0.0,
-                "tx_throughput_fps": 5.9,
-                "rx_throughput_mbps": 434.78,
-                "tx_throughput_mbps": 0.0,
-                "in_packets": 0,
-                "out_packets": 48791,
-            },
-        }
-        ports = vnfd_helper.port_nums(vnfd_helper.port_pairs.all_ports)
-        result = client_resource_helper.generate_samples(ports, 'key_name', 'default')
-        self.assertDictEqual(result, expected)
-
     def test_clear_stats(self):
         vnfd_helper = VnfdHelper(self.VNFD_0)
         ssh_helper = mock.Mock()
         scenario_helper = mock.Mock()
-        dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
+        dpdk_setup_helper = DpdkVnfSetupEnvHelper(
+            vnfd_helper, ssh_helper, scenario_helper)
         client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
         client_resource_helper.client = mock.Mock()
 
         self.assertIsNone(client_resource_helper.clear_stats())
-        client_resource_helper.client.clear_stats.assert_called_once()
+        self.assertEqual(
+            client_resource_helper.client.clear_stats.call_count, 1)
 
     def test_clear_stats_of_ports(self):
         vnfd_helper = VnfdHelper(self.VNFD_0)
         ssh_helper = mock.Mock()
         scenario_helper = mock.Mock()
-        dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
+        dpdk_setup_helper = DpdkVnfSetupEnvHelper(
+            vnfd_helper, ssh_helper, scenario_helper)
         client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
         client_resource_helper.client = mock.Mock()
 
         self.assertIsNone(client_resource_helper.clear_stats([3, 4]))
-        client_resource_helper.client.clear_stats.assert_called_once()
+        self.assertEqual(
+            client_resource_helper.client.clear_stats.call_count, 1)
 
     def test_start(self):
         vnfd_helper = VnfdHelper(self.VNFD_0)
         ssh_helper = mock.Mock()
         scenario_helper = mock.Mock()
-        dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
+        dpdk_setup_helper = DpdkVnfSetupEnvHelper(
+            vnfd_helper, ssh_helper, scenario_helper)
         client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
         client_resource_helper.client = mock.Mock()
 
@@ -1192,7 +1048,8 @@ class TestClientResourceHelper(unittest.TestCase):
         vnfd_helper = VnfdHelper(self.VNFD_0)
         ssh_helper = mock.Mock()
         scenario_helper = mock.Mock()
-        dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
+        dpdk_setup_helper = DpdkVnfSetupEnvHelper(
+            vnfd_helper, ssh_helper, scenario_helper)
         client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
         client_resource_helper.client = mock.Mock()
 
@@ -1219,17 +1076,15 @@ class TestClientResourceHelper(unittest.TestCase):
         self.assertDictEqual(result, expected)
 
     @mock.patch('yardstick.network_services.vnf_generic.vnf.sample_vnf.time')
-    @mock.patch('yardstick.network_services.vnf_generic.vnf.sample_vnf.LOG')
-    @mock.patch('yardstick.network_services.vnf_generic.vnf.sample_vnf.STLError',
-                new_callable=lambda: MockError)
-    def test__connect_with_failures(self, mock_error, *args):
+    @mock.patch.object(sample_vnf, 'STLError')
+    def test__connect_with_failures(self, mock_stl_error, *args):
         vnfd_helper = VnfdHelper(self.VNFD_0)
         ssh_helper = mock.Mock()
         scenario_helper = mock.Mock()
         dpdk_setup_helper = DpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
         client_resource_helper = ClientResourceHelper(dpdk_setup_helper)
         client = mock.MagicMock()
-        client.connect.side_effect = mock_error
+        client.connect.side_effect = mock_stl_error(msg='msg')
 
         self.assertIs(client_resource_helper._connect(client), client)
 
@@ -1678,7 +1533,7 @@ class TestSampleVnf(unittest.TestCase):
 
     @mock.patch("yardstick.ssh.SSH")
     def test_instantiate(self, ssh):
-        mock_ssh(ssh)
+        test_base.mock_ssh(ssh)
 
         nodes = {
             'vnf1': 'name1',
@@ -1778,7 +1633,7 @@ class TestSampleVnf(unittest.TestCase):
     @mock.patch("yardstick.network_services.vnf_generic.vnf.sample_vnf.time")
     @mock.patch("yardstick.ssh.SSH")
     def test_wait_for_instantiate_empty_queue(self, ssh, *args):
-        mock_ssh(ssh, exec_result=(1, "", ""))
+        test_base.mock_ssh(ssh, exec_result=(1, "", ""))
 
         queue_size_list = [
             0,
diff --git a/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_rfc2544_trex.py b/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_rfc2544_trex.py
index 8b1b8a39c..9531b90c4 100644
--- a/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_rfc2544_trex.py
+++ b/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_rfc2544_trex.py
@@ -11,44 +11,37 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-#
 
-import unittest
 import mock
+import unittest
 
-from yardstick.tests import STL_MOCKS
-SSH_HELPER = 'yardstick.network_services.vnf_generic.vnf.sample_vnf.VnfSshHelper'
-
-
-STLClient = mock.MagicMock()
-stl_patch = mock.patch.dict("sys.modules", STL_MOCKS)
-stl_patch.start()
-
-if stl_patch:
-    from yardstick.network_services.vnf_generic.vnf.tg_rfc2544_trex import TrexTrafficGenRFC, \
-        TrexRfcResourceHelper
-    from yardstick.network_services.vnf_generic.vnf import tg_rfc2544_trex
-    from yardstick.network_services.traffic_profile.base import TrafficProfile
-    from yardstick.tests.unit.network_services.vnf_generic.vnf.test_base \
-        import FileAbsPath, mock_ssh
-
-MODULE_PATH = FileAbsPath(__file__)
-get_file_abspath = MODULE_PATH.get_path
+from yardstick.network_services.traffic_profile import base as tp_base
+from yardstick.network_services.vnf_generic.vnf import sample_vnf
+from yardstick.network_services.vnf_generic.vnf import tg_rfc2544_trex
 
 
 class TestTrexRfcResouceHelper(unittest.TestCase):
 
-    @mock.patch('yardstick.network_services.helpers.samplevnf_helper.MultiPortConfig')
-    @mock.patch("yardstick.network_services.vnf_generic.vnf.tg_rfc2544_trex.time")
-    @mock.patch(SSH_HELPER)
-    def test__run_traffic_once(self, ssh, *_):
-        mock_ssh(ssh)
+    def test__run_traffic_once(self):
+        mock_setup_helper = mock.Mock()
+        mock_traffic_profile = mock.Mock()
+        mock_traffic_profile.config.duration = 3
+        mock_traffic_profile.execute_traffic.return_value = ('fake_ports',
+                                                             'port_pg_id_map')
+        mock_traffic_profile.get_drop_percentage.return_value = 'percentage'
+        rfc_rh = tg_rfc2544_trex.TrexRfcResourceHelper(mock_setup_helper)
+        rfc_rh.TRANSIENT_PERIOD = 0
+        rfc_rh.rfc2544_helper = mock.Mock()
 
-        mock_traffic_profile = mock.MagicMock(autospec=TrafficProfile,
-                                              **{'get_drop_percentage.return_value': {}})
-        sut = TrexRfcResourceHelper(mock.MagicMock(), mock.MagicMock())
-        sut.client = mock.MagicMock()
-        sut._run_traffic_once(mock_traffic_profile)
+        with mock.patch.object(rfc_rh, '_get_samples') as mock_get_samples:
+            rfc_rh._run_traffic_once(mock_traffic_profile)
+
+        mock_traffic_profile.execute_traffic.assert_called_once_with(rfc_rh)
+        mock_traffic_profile.stop_traffic.assert_called_once_with(rfc_rh)
+        mock_traffic_profile.stop_traffic.assert_called_once()
+        mock_get_samples.assert_has_calls([
+            mock.call('fake_ports', port_pg_id='port_pg_id_map'),
+            mock.call('fake_ports', port_pg_id='port_pg_id_map')])
 
 
 class TestTrexTrafficGenRFC(unittest.TestCase):
@@ -219,33 +212,24 @@ class TestTrexTrafficGenRFC(unittest.TestCase):
         'schema': 'yardstick:task:0.1',
     }
 
-    @mock.patch(SSH_HELPER)
-    def test___init__(self, ssh):
-        mock_ssh(ssh)
-        trex_traffic_gen = TrexTrafficGenRFC('vnf1', self.VNFD_0)
-        self.assertIsNotNone(trex_traffic_gen.resource_helper._terminated.value)
+    def setUp(self):
+        self._mock_ssh_helper = mock.patch.object(sample_vnf, 'VnfSshHelper')
+        self.mock_ssh_helper = self._mock_ssh_helper.start()
+        self.addCleanup(self._stop_mocks)
 
-    @mock.patch(SSH_HELPER)
-    def test_collect_kpi(self, ssh):
-        mock_ssh(ssh)
-        trex_traffic_gen = TrexTrafficGenRFC('vnf1', self.VNFD_0)
-        self.assertEqual(trex_traffic_gen.collect_kpi(), {})
+    def _stop_mocks(self):
+        self._mock_ssh_helper.stop()
 
-    @mock.patch(SSH_HELPER)
-    def test_listen_traffic(self, ssh):
-        mock_ssh(ssh)
-        trex_traffic_gen = TrexTrafficGenRFC('vnf1', self.VNFD_0)
-        self.assertIsNone(trex_traffic_gen.listen_traffic({}))
-
-    @mock.patch(SSH_HELPER)
-    def test_instantiate(self, ssh):
-        mock_ssh(ssh)
+    def test___init__(self):
+        trex_traffic_gen = tg_rfc2544_trex.TrexTrafficGenRFC('vnf1', self.VNFD_0)
+        self.assertIsNotNone(trex_traffic_gen.resource_helper._terminated.value)
 
-        mock_traffic_profile = mock.Mock(autospec=TrafficProfile)
+    def test_instantiate(self):
+        mock_traffic_profile = mock.Mock(autospec=tp_base.TrafficProfile)
         mock_traffic_profile.get_traffic_definition.return_value = "64"
         mock_traffic_profile.params = self.TRAFFIC_PROFILE
 
-        trex_traffic_gen = TrexTrafficGenRFC('vnf1', self.VNFD_0)
+        trex_traffic_gen = tg_rfc2544_trex.TrexTrafficGenRFC('vnf1', self.VNFD_0)
         trex_traffic_gen._start_server = mock.Mock(return_value=0)
         trex_traffic_gen.resource_helper = mock.MagicMock()
         trex_traffic_gen.setup_helper.setup_vnf_environment = mock.MagicMock()
@@ -274,15 +258,12 @@ class TestTrexTrafficGenRFC(unittest.TestCase):
         scenario_cfg.update({"nodes": ["tg_1", "vnf_1"]})
         self.assertIsNone(trex_traffic_gen.instantiate(scenario_cfg, {}))
 
-    @mock.patch(SSH_HELPER)
-    def test_instantiate_error(self, ssh):
-        mock_ssh(ssh, exec_result=(1, "", ""))
-
-        mock_traffic_profile = mock.Mock(autospec=TrafficProfile)
+    def test_instantiate_error(self):
+        mock_traffic_profile = mock.Mock(autospec=tp_base.TrafficProfile)
         mock_traffic_profile.get_traffic_definition.return_value = "64"
         mock_traffic_profile.params = self.TRAFFIC_PROFILE
 
-        trex_traffic_gen = TrexTrafficGenRFC('vnf1', self.VNFD_0)
+        trex_traffic_gen = tg_rfc2544_trex.TrexTrafficGenRFC('vnf1', self.VNFD_0)
         trex_traffic_gen.resource_helper = mock.MagicMock()
         trex_traffic_gen.setup_helper.setup_vnf_environment = mock.MagicMock()
         scenario_cfg = {
@@ -310,29 +291,3 @@ class TestTrexTrafficGenRFC(unittest.TestCase):
             },
         }
         trex_traffic_gen.instantiate(scenario_cfg, {})
-
-    @mock.patch(SSH_HELPER)
-    def test__start_server(self, ssh):
-        mock_ssh(ssh)
-        trex_traffic_gen = TrexTrafficGenRFC('vnf1', self.VNFD_0)
-        trex_traffic_gen.resource_helper = mock.MagicMock()
-        self.assertIsNone(trex_traffic_gen._start_server())
-
-    @mock.patch("yardstick.network_services.vnf_generic.vnf.tg_rfc2544_trex.time")
-    @mock.patch(SSH_HELPER)
-    def test__generate_trex_cfg(self, ssh, _):
-        mock_ssh(ssh)
-
-        trex_traffic_gen = TrexTrafficGenRFC('vnf1', self.VNFD_0)
-        trex_traffic_gen.ssh_helper = mock.MagicMock()
-        trex_traffic_gen.resource_helper.ssh_helper = mock.MagicMock()
-        self.assertIsNone(trex_traffic_gen.resource_helper.generate_cfg())
-
-    def test_terminate(self):
-        with mock.patch(SSH_HELPER) as ssh:
-            ssh_mock = mock.Mock(autospec=ssh.SSH)
-            ssh_mock.execute = mock.Mock(return_value=(0, "", ""))
-            ssh.from_node.return_value = ssh_mock
-            trex_traffic_gen = TrexTrafficGenRFC('vnf1', self.VNFD_0)
-            trex_traffic_gen.resource_helper = mock.MagicMock()
-            self.assertIsNone(trex_traffic_gen.terminate())
diff --git a/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_trex.py b/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_trex.py
index aae3d468f..4f8742477 100644
--- a/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_trex.py
+++ b/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_trex.py
@@ -11,31 +11,23 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-#
 
 import copy
 
 import mock
 import unittest
 
-from yardstick.tests.unit.network_services.vnf_generic.vnf.test_base import mock_ssh
-from yardstick.tests import STL_MOCKS
+from yardstick.network_services.traffic_profile import base as tp_base
+from yardstick.network_services.traffic_profile import rfc2544
+from yardstick.network_services.vnf_generic.vnf import sample_vnf
+from yardstick.network_services.vnf_generic.vnf import tg_trex
 
 
-SSH_HELPER = 'yardstick.network_services.vnf_generic.vnf.sample_vnf.VnfSshHelper'
 NAME = 'vnf_1'
 
-STLClient = mock.MagicMock()
-stl_patch = mock.patch.dict("sys.modules", STL_MOCKS)
-stl_patch.start()
-
-if stl_patch:
-    from yardstick.network_services.vnf_generic.vnf.tg_trex import \
-        TrexTrafficGen, TrexResourceHelper
-    from yardstick.network_services.traffic_profile.base import TrafficProfile
-
 
 class TestTrexTrafficGen(unittest.TestCase):
+
     VNFD = {'vnfd:vnfd-catalog':
             {'vnfd':
              [{'short-name': 'VpeVnf',
@@ -168,7 +160,7 @@ class TestTrexTrafficGen(unittest.TestCase):
                 "interfaces": {
                     "xe0": {
                         "local_iface_name": "ens786f0",
-                        "vld_id": TrafficProfile.UPLINK,
+                        "vld_id": tp_base.TrafficProfile.UPLINK,
                         "netmask": "255.255.255.0",
                         "vpci": "0000:05:00.0",
                         "local_ip": "152.16.100.19",
@@ -180,7 +172,7 @@ class TestTrexTrafficGen(unittest.TestCase):
                     },
                     "xe1": {
                         "local_iface_name": "ens786f1",
-                        "vld_id": TrafficProfile.DOWNLINK,
+                        "vld_id": tp_base.TrafficProfile.DOWNLINK,
                         "netmask": "255.255.255.0",
                         "vpci": "0000:05:00.1",
                         "local_ip": "152.16.40.19",
@@ -236,7 +228,7 @@ class TestTrexTrafficGen(unittest.TestCase):
                 "interfaces": {
                     "xe0": {
                         "local_iface_name": "ens513f0",
-                        "vld_id": TrafficProfile.DOWNLINK,
+                        "vld_id": tp_base.TrafficProfile.DOWNLINK,
                         "netmask": "255.255.255.0",
                         "vpci": "0000:02:00.0",
                         "local_ip": "152.16.40.20",
@@ -270,7 +262,7 @@ class TestTrexTrafficGen(unittest.TestCase):
                 "interfaces": {
                     "xe0": {
                         "local_iface_name": "ens785f0",
-                        "vld_id": TrafficProfile.UPLINK,
+                        "vld_id": tp_base.TrafficProfile.UPLINK,
                         "netmask": "255.255.255.0",
                         "vpci": "0000:05:00.0",
                         "local_ip": "152.16.100.20",
@@ -297,36 +289,35 @@ class TestTrexTrafficGen(unittest.TestCase):
         }
     }
 
-    @mock.patch(SSH_HELPER)
-    def test___init__(self, ssh):
-        mock_ssh(ssh)
+    def setUp(self):
+        self._mock_ssh_helper = mock.patch.object(sample_vnf, 'VnfSshHelper')
+        self.mock_ssh_helper = self._mock_ssh_helper.start()
+        self.addCleanup(self._stop_mocks)
+
+    def _stop_mocks(self):
+        self._mock_ssh_helper.stop()
+
+    def test___init__(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
-        self.assertIsInstance(
-            trex_traffic_gen.resource_helper, TrexResourceHelper)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
+        self.assertIsInstance(trex_traffic_gen.resource_helper,
+                              tg_trex.TrexResourceHelper)
 
-    @mock.patch(SSH_HELPER)
-    def test_collect_kpi(self, ssh):
-        mock_ssh(ssh)
+    def test_collect_kpi(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         trex_traffic_gen.resource_helper._queue.put({})
         result = trex_traffic_gen.collect_kpi()
         self.assertEqual({}, result)
 
-    @mock.patch(SSH_HELPER)
-    def test_listen_traffic(self, ssh):
-        mock_ssh(ssh)
+    def test_listen_traffic(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         self.assertIsNone(trex_traffic_gen.listen_traffic({}))
 
-    @mock.patch(SSH_HELPER)
-    def test_instantiate(self, ssh):
-        mock_ssh(ssh)
-
+    def test_instantiate(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         trex_traffic_gen._start_server = mock.Mock(return_value=0)
         trex_traffic_gen._tg_process = mock.MagicMock()
         trex_traffic_gen._tg_process.start = mock.Mock()
@@ -335,16 +326,12 @@ class TestTrexTrafficGen(unittest.TestCase):
         trex_traffic_gen.ssh_helper = mock.MagicMock()
         trex_traffic_gen.resource_helper.ssh_helper = mock.MagicMock()
         trex_traffic_gen.setup_helper.setup_vnf_environment = mock.MagicMock()
+        self.assertIsNone(trex_traffic_gen.instantiate(self.SCENARIO_CFG,
+                                                       self.CONTEXT_CFG))
 
-        self.assertIsNone(trex_traffic_gen.instantiate(
-            self.SCENARIO_CFG, self.CONTEXT_CFG))
-
-    @mock.patch(SSH_HELPER)
-    def test_instantiate_error(self, ssh):
-        mock_ssh(ssh, exec_result=(1, "", ""))
-
+    def test_instantiate_error(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         trex_traffic_gen._start_server = mock.Mock(return_value=0)
         trex_traffic_gen._tg_process = mock.MagicMock()
         trex_traffic_gen._tg_process.start = mock.Mock()
@@ -352,62 +339,53 @@ class TestTrexTrafficGen(unittest.TestCase):
         trex_traffic_gen.ssh_helper = mock.MagicMock()
         trex_traffic_gen.resource_helper.ssh_helper = mock.MagicMock()
         trex_traffic_gen.setup_helper.setup_vnf_environment = mock.MagicMock()
-        self.assertIsNone(trex_traffic_gen.instantiate(
-            self.SCENARIO_CFG, self.CONTEXT_CFG))
+        self.assertIsNone(trex_traffic_gen.instantiate(self.SCENARIO_CFG,
+                                                       self.CONTEXT_CFG))
 
-    @mock.patch(SSH_HELPER)
-    def test__start_server(self, ssh):
-        mock_ssh(ssh)
+    def test__start_server(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         trex_traffic_gen.ssh_helper = mock.MagicMock()
         trex_traffic_gen.resource_helper.ssh_helper = mock.MagicMock()
         trex_traffic_gen.scenario_helper.scenario_cfg = {}
         self.assertIsNone(trex_traffic_gen._start_server())
 
-    @mock.patch(SSH_HELPER)
-    def test__start_server_multiple_queues(self, ssh):
-        mock_ssh(ssh)
+    def test__start_server_multiple_queues(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         trex_traffic_gen.ssh_helper = mock.MagicMock()
         trex_traffic_gen.resource_helper.ssh_helper = mock.MagicMock()
         trex_traffic_gen.scenario_helper.scenario_cfg = {
             "options": {NAME: {"queues_per_port": 2}}}
         self.assertIsNone(trex_traffic_gen._start_server())
 
-    @mock.patch(SSH_HELPER)
-    def test__traffic_runner(self, ssh):
-        mock_ssh(ssh)
-
-        mock_traffic_profile = mock.Mock(autospec=TrafficProfile)
+    def test__traffic_runner(self):
+        mock_traffic_profile = mock.Mock(autospec=tp_base.TrafficProfile)
         mock_traffic_profile.get_traffic_definition.return_value = "64"
         mock_traffic_profile.execute_traffic.return_value = "64"
         mock_traffic_profile.params = self.TRAFFIC_PROFILE
 
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        self.sut = TrexTrafficGen(NAME, vnfd)
+        self.sut = tg_trex.TrexTrafficGen(NAME, vnfd)
         self.sut.ssh_helper = mock.Mock()
         self.sut.ssh_helper.run = mock.Mock()
-        self.sut._connect_client = mock.Mock(autospec=STLClient)
+        self.sut._connect_client = mock.Mock()
         self.sut._connect_client.get_stats = mock.Mock(return_value="0")
         self.sut.resource_helper.RUN_DURATION = 0
         self.sut.resource_helper.QUEUE_WAIT_TIME = 0
-        # must generate cfg before we can run traffic so Trex port mapping is created
+        # must generate cfg before we can run traffic so Trex port mapping is
+        # created
         self.sut.resource_helper.generate_cfg()
-        self.sut._traffic_runner(mock_traffic_profile)
+        with mock.patch.object(self.sut.resource_helper, 'run_traffic'):
+            self.sut._traffic_runner(mock_traffic_profile)
 
-    @mock.patch(SSH_HELPER)
-    def test__generate_trex_cfg(self, ssh):
-        mock_ssh(ssh)
+    def test__generate_trex_cfg(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         trex_traffic_gen.resource_helper.ssh_helper = mock.MagicMock()
         self.assertIsNone(trex_traffic_gen.resource_helper.generate_cfg())
 
-    @mock.patch(SSH_HELPER)
-    def test_build_ports_reversed_pci_ordering(self, ssh):
-        mock_ssh(ssh)
+    def test_build_ports_reversed_pci_ordering(self):
         vnfd = copy.deepcopy(self.VNFD['vnfd:vnfd-catalog']['vnfd'][0])
         vnfd['vdu'][0]['external-interface'] = [
             {'virtual-interface':
@@ -442,26 +420,24 @@ class TestTrexTrafficGen(unittest.TestCase):
               'local_mac': '00:00:00:00:00:01'},
              'vnfd-connection-point-ref': 'xe1',
              'name': 'xe1'}]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         trex_traffic_gen.resource_helper.ssh_helper = mock.MagicMock()
         trex_traffic_gen.resource_helper.generate_cfg()
         trex_traffic_gen.resource_helper._build_ports()
-        self.assertEqual(
-            sorted(trex_traffic_gen.resource_helper.all_ports), [0, 1])
+        self.assertEqual(sorted(trex_traffic_gen.resource_helper.all_ports),
+                         [0, 1])
         # there is a gap in ordering
-        self.assertEqual(dict(trex_traffic_gen.resource_helper.dpdk_to_trex_port_map),
-                         {0: 0, 2: 1})
-
-    @mock.patch(SSH_HELPER)
-    def test_run_traffic(self, ssh):
-        mock_ssh(ssh)
+        self.assertEqual(
+            {0: 0, 2: 1},
+            dict(trex_traffic_gen.resource_helper.dpdk_to_trex_port_map))
 
-        mock_traffic_profile = mock.Mock(autospec=TrafficProfile)
+    def test_run_traffic(self):
+        mock_traffic_profile = mock.Mock(autospec=tp_base.TrafficProfile)
         mock_traffic_profile.get_traffic_definition.return_value = "64"
         mock_traffic_profile.params = self.TRAFFIC_PROFILE
 
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        self.sut = TrexTrafficGen(NAME, vnfd)
+        self.sut = tg_trex.TrexTrafficGen(NAME, vnfd)
         self.sut.ssh_helper = mock.Mock()
         self.sut.ssh_helper.run = mock.Mock()
         self.sut._traffic_runner = mock.Mock(return_value=0)
@@ -470,20 +446,60 @@ class TestTrexTrafficGen(unittest.TestCase):
         self.sut._traffic_process.terminate()
         self.assertIsNotNone(result)
 
-    @mock.patch(SSH_HELPER)
-    def test_terminate(self, ssh):
-        mock_ssh(ssh)
+    def test_terminate(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
         trex_traffic_gen.ssh_helper = mock.MagicMock()
         trex_traffic_gen.resource_helper.ssh_helper = mock.MagicMock()
         self.assertIsNone(trex_traffic_gen.terminate())
 
-    @mock.patch(SSH_HELPER)
-    def test__connect_client(self, ssh):
-        mock_ssh(ssh)
+    def test__connect_client(self):
         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
-        trex_traffic_gen = TrexTrafficGen(NAME, vnfd)
-        client = mock.Mock(autospec=STLClient)
+        trex_traffic_gen = tg_trex.TrexTrafficGen(NAME, vnfd)
+        client = mock.Mock()
         client.connect = mock.Mock(return_value=0)
         self.assertIsNotNone(trex_traffic_gen.resource_helper._connect(client))
+
+
+class TrexResourceHelperTestCase(unittest.TestCase):
+
+    def test__get_samples(self):
+        mock_setup_helper = mock.Mock()
+        trex_rh = tg_trex.TrexResourceHelper(mock_setup_helper)
+        trex_rh.vnfd_helper.interfaces = [
+            {'name': 'interface1'},
+            {'name': 'interface2'}]
+        stats = {
+            10: {'rx_pps': 5, 'ipackets': 200},
+            20: {'rx_pps': 10, 'ipackets': 300},
+            'latency': {1: {'latency': 'latency_port_10_pg_id_1'},
+                        2: {'latency': 'latency_port_10_pg_id_2'},
+                        3: {'latency': 'latency_port_20_pg_id_3'},
+                        4: {'latency': 'latency_port_20_pg_id_4'}}
+        }
+        port_pg_id = rfc2544.PortPgIDMap()
+        port_pg_id.add_port(10)
+        port_pg_id.increase_pg_id()
+        port_pg_id.increase_pg_id()
+        port_pg_id.add_port(20)
+        port_pg_id.increase_pg_id()
+        port_pg_id.increase_pg_id()
+
+        with mock.patch.object(trex_rh, 'get_stats') as mock_get_stats, \
+                mock.patch.object(trex_rh.vnfd_helper, 'port_num') as \
+                mock_port_num:
+            mock_get_stats.return_value = stats
+            mock_port_num.side_effect = [10, 20]
+            output = trex_rh._get_samples([10, 20], port_pg_id=port_pg_id)
+
+        interface = output['interface1']
+        self.assertEqual(5.0, interface['rx_throughput_fps'])
+        self.assertEqual(200, interface['in_packets'])
+        self.assertEqual('latency_port_10_pg_id_1', interface['latency'][1])
+        self.assertEqual('latency_port_10_pg_id_2', interface['latency'][2])
+
+        interface = output['interface2']
+        self.assertEqual(10.0, interface['rx_throughput_fps'])
+        self.assertEqual(300, interface['in_packets'])
+        self.assertEqual('latency_port_20_pg_id_3', interface['latency'][3])
+        self.assertEqual('latency_port_20_pg_id_4', interface['latency'][4])