Merge branch 'master' into dan_stateless

80 files changed, 39063 insertions, 3962 deletions

diff --git a/.gitignore b/.gitignore
index cfe53466..de45a1ef 100644
--- a/.gitignore
+++ b/.gitignore
@@ -31,6 +31,16 @@ scripts/exp/stl_bb_start_stop3-0.erf
 scripts/exp/stl_bb_start_stop_delay1-0.erf
 scripts/exp/stl_bb_start_stop_delay2-0.erf
 scripts/exp/stl_basic_pause_resume0-0.erf
+scripts/exp/stl_vm_enable0-0.erf
+scripts/exp/stl_vm_enable1-0.erf
+scripts/exp/stl_vm_enable2-0.erf
+scripts/exp/udp_64B_vm6.pcap
+scripts/exp/udp_64B_vm7.pcap
+scripts/exp/udp_64B_vm8.pcap
+scripts/exp/udp_64B_vm9.pcap
+
+
+
 
 
 
diff --git a/VERSION b/VERSION
index 3c77d029..a8d9f812 100755
--- a/VERSION
+++ b/VERSION
@@ -1,4 +1,5 @@
-v1.80
+v1.83
+
 
 
 
diff --git a/linux/ws_main.py b/linux/ws_main.py
index 617bcf37..b0499842 100755
--- a/linux/ws_main.py
+++ b/linux/ws_main.py
@@ -118,6 +118,7 @@ main_src = SrcGroup(dir='src',
              'utl_cpuu.cpp',
              'msg_manager.cpp',
              'publisher/trex_publisher.cpp',
+	     'latency.cpp',
 
              'pal/linux/pal_utl.cpp',
              'pal/linux/mbuf.cpp'
diff --git a/linux_dpdk/ws_main.py b/linux_dpdk/ws_main.py
index 89f41376..e5ac40fb 100755
--- a/linux_dpdk/ws_main.py
+++ b/linux_dpdk/ws_main.py
@@ -12,6 +12,7 @@ import shutil;
 import copy;
 import re
 import uuid
+import subprocess
 
 
 # these variables are mandatory ('/' are converted automatically)
@@ -95,6 +96,7 @@ main_src = SrcGroup(dir='src',
              'global_io_mode.cpp',
              'main_dpdk.cpp',
              'bp_sim.cpp',
+             'latency.cpp',
              'platform_cfg.cpp',
              'tuple_gen.cpp',
              'rx_check.cpp',
@@ -701,6 +703,15 @@ def get_build_num ():
     return s;
 
 def create_version_files ():
+    git_sha="N/A"
+    try:
+      r=commands.getstatusoutput("git log --pretty=format:'%H' -n 1")
+      if r[0]==0:
+          git_sha=r[1]
+    except :
+        pass;
+
+
     s =''
     s +="#ifndef __TREX_VER_FILE__           \n"
     s +="#define __TREX_VER_FILE__           \n"
@@ -711,6 +722,7 @@ def create_version_files ():
     s +='extern const char * get_build_date(void);  \n'
     s +='extern const char * get_build_time(void);  \n'
     s +='#define VERSION_UIID      "%s"       \n' % uuid.uuid1()
+    s +='#define VERSION_GIT_SHA   "%s"       \n' % git_sha
     s +='#define VERSION_BUILD_NUM "%s"       \n' % get_build_num()
     s +="#ifdef __cplusplus                  \n"
     s +=" }                        \n"
@@ -876,6 +888,12 @@ def publish_ext(bld):
 
 
 
+def test (bld):
+    r=commands.getstatusoutput("git log --pretty=format:'%H' -n 1")
+    if r[0]==0:
+        print r[1]
+
+
 
 
 
diff --git a/linux_dpdk/wscript b/linux_dpdk/wscript
index be048bd8..459e2201 100755
--- a/linux_dpdk/wscript
+++ b/linux_dpdk/wscript
@@ -45,6 +45,9 @@ def publish_web(bld):
 def sync(bld):
       ws_main.sync(bld)
       
+def test(bld):
+      ws_main.test(bld)
+
 
 
 
diff --git a/scripts/automation/trex_control_plane/client/trex_async_client.py b/scripts/automation/trex_control_plane/client/trex_async_client.py
index 8b274134..459d6915 100644
--- a/scripts/automation/trex_control_plane/client/trex_async_client.py
+++ b/scripts/automation/trex_control_plane/client/trex_async_client.py
@@ -19,6 +19,7 @@ import re
 
 from common.trex_stats import *
 from common.trex_streams import *
+from common.trex_types import *
 
 # basic async stats class
 class CTRexAsyncStats(object):
@@ -152,38 +153,115 @@ class CTRexAsyncStatsManager():
 
 
 class CTRexAsyncClient():
-    def __init__ (self, server, port, stateless_client):
+    def __init__ (self, server, port, stateless_client, prn_func = None):
 
         self.port = port
         self.server = server
         self.stateless_client = stateless_client
+        self.prn_func = prn_func
 
         self.raw_snapshot = {}
 
         self.stats = CTRexAsyncStatsManager()
 
+        self.last_data_recv_ts = 0
+
+        self.connected = False
+ 
+    # connects the async channel
+    def connect (self):
+
+        if self.connected:
+            self.disconnect()
 
         self.tr = "tcp://{0}:{1}".format(self.server, self.port)
-        print "\nConnecting To ZMQ Publisher At {0}".format(self.tr)
 
+        msg = "\nConnecting To ZMQ Publisher On {0}".format(self.tr)
+
+        if self.prn_func:
+            self.prn_func(msg)
+        else:
+            print msg
+
+        #  Socket to talk to server
+        self.context = zmq.Context()
+        self.socket = self.context.socket(zmq.SUB)
+
+
+        # before running the thread - mark as active
         self.active = True
-        self.t = threading.Thread(target= self.run)
+        self.t = threading.Thread(target = self._run)
 
         # kill this thread on exit and don't add it to the join list
         self.t.setDaemon(True)
         self.t.start()
 
-    def run(self):
+        self.connected = True
 
-        #  Socket to talk to server
-        self.context = zmq.Context()
-        self.socket = self.context.socket(zmq.SUB)
 
+        # wait for data streaming from the server
+        timeout = time.time() + 5
+        while not self.is_alive():
+            time.sleep(0.01)
+            if time.time() > timeout:
+                self.disconnect()
+                return RC_ERR("*** [subscriber] - no data flow from server at : " + self.tr)
+
+        return RC_OK()
+
+
+    # disconnect
+    def disconnect (self):
+        if not self.connected:
+            return
+
+        # signal that the context was destroyed (exit the thread loop)
+        self.context.term()
+
+        # mark for join and join
+        self.active = False
+        self.t.join()
+
+        # done
+        self.connected = False
+
+    # thread function
+    def _run (self):
+
+
+        # socket must be created on the same thread 
         self.socket.connect(self.tr)
         self.socket.setsockopt(zmq.SUBSCRIBE, '')
+        self.socket.setsockopt(zmq.RCVTIMEO, 5000)
+
+        got_data = False
 
         while self.active:
-            line = self.socket.recv_string()
+            try:
+
+                line = self.socket.recv_string()
+                self.last_data_recv_ts = time.time()
+
+                # signal once
+                if not got_data:
+                    self.stateless_client.on_async_alive()
+                    got_data = True
+                
+
+            # got a timeout - mark as not alive and retry
+            except zmq.Again:
+
+                # signal once
+                if got_data:
+                    self.stateless_client.on_async_dead()
+                    got_data = False
+
+                continue
+
+            except zmq.ContextTerminated:
+                # outside thread signaled us to exit
+                break
+
             msg = json.loads(line)
 
             name = msg['name']
@@ -193,7 +271,19 @@ class CTRexAsyncClient():
 
             self.__dispatch(name, type, data)
 
-    def get_stats(self):
+        
+        # closing of socket must be from the same thread
+        self.socket.close(linger = 0)
+
+
+    # did we get info for the last 3 seconds ?
+    def is_alive (self):
+        if self.last_data_recv_ts == None:
+            return False
+
+        return ( (time.time() - self.last_data_recv_ts) < 3 )
+
+    def get_stats (self):
         return self.stats
 
     def get_raw_snapshot (self):
@@ -203,7 +293,6 @@ class CTRexAsyncClient():
     def __dispatch (self, name, type, data):
         # stats
         if name == "trex-global":
-            # self.stats.update(data)
             self.stateless_client.handle_async_stats_update(data)
         # events
         elif name == "trex-event":
@@ -212,10 +301,3 @@ class CTRexAsyncClient():
             pass
 
 
-    def stop (self):
-        self.active = False
-        self.t.join()
-
-
-if __name__ == "__main__":
-    pass
\ No newline at end of file
diff --git a/scripts/automation/trex_control_plane/client/trex_client.py b/scripts/automation/trex_control_plane/client/trex_client.py
index 160abdec..5709b7a5 100755
--- a/scripts/automation/trex_control_plane/client/trex_client.py
+++ b/scripts/automation/trex_control_plane/client/trex_client.py
@@ -88,7 +88,7 @@ class CTRexClient(object):
         finally:
             self.prompt_verbose_data()
 
-    def start_trex (self, f, d, block_to_success = True, timeout = 30, user = None, **trex_cmd_options):
+    def start_trex (self, f, d, block_to_success = True, timeout = 40, user = None, trex_development = False, **trex_cmd_options):
         """
         Request to start a TRex run on server.
                 
@@ -104,7 +104,7 @@ class CTRexClient(object):
             timeout : int
                 maximum time (in seconds) to wait in blocking state until TRex changes state from 'Starting' to either 'Idle' or 'Running'
 
-                default value: **30**
+                default value: **40**
             user : str
                 the identity of the the run issuer.
             trex_cmd_options : key, val
@@ -125,13 +125,17 @@ class CTRexClient(object):
         user = user or self.__default_user
         try:
             d = int(d)
-            if d < 30:  # specify a test should take at least 30 seconds long.
+            if d < 30 and not trex_development:  # test duration should be at least 30 seconds, unless trex_development flag is specified.
                 raise ValueError
         except ValueError:
             raise ValueError('d parameter must be integer, specifying how long TRex run, and must be larger than 30 secs.')
 
         trex_cmd_options.update( {'f' : f, 'd' : d} )
-        
+        if not trex_cmd_options.get('l'):
+            self.result_obj.latency_checked = False
+        if 'k' in trex_cmd_options:
+            timeout += int(trex_cmd_options['k']) # during 'k' seconds TRex stays in 'Starting' state
+
         self.result_obj.clear_results()
         try:
             issue_time = time.time()
@@ -544,7 +548,7 @@ class CTRexClient(object):
         Get TRex version details.
 
         :return: 
-            Trex details (Version, User, Date, Uuid) as ordered dictionary
+            Trex details (Version, User, Date, Uuid, Git SHA) as ordered dictionary
 
         :raises:
             + :exc:`trex_exceptions.TRexRequestDenied`, in case TRex version could not be determined.
@@ -556,9 +560,11 @@ class CTRexClient(object):
             version_dict = OrderedDict()
             result_lines = binascii.a2b_base64(self.server.get_trex_version()).split('\n')
             for line in result_lines:
+                if not line:
+                    continue
                 key, value = line.strip().split(':', 1)
                 version_dict[key.strip()] = value.strip()
-            for key in ('Version', 'User', 'Date', 'Uuid'):
+            for key in ('Version', 'User', 'Date', 'Uuid', 'Git SHA'):
                 if key not in version_dict:
                     raise Exception('get_trex_version: got server response without key: {0}'.format(key))
             return version_dict
@@ -767,6 +773,7 @@ class CTRexResult(object):
         """
         self._history = deque(maxlen = max_history_size)
         self.clear_results()
+        self.latency_checked = True
 
     def __repr__(self):
         return ("Is valid history?       {arg}\n".format( arg = self.is_valid_hist() ) +
@@ -1032,18 +1039,19 @@ class CTRexResult(object):
                     self._done_warmup = True
             
             # handle latency data
-            latency_pre = "trex-latency"
-            self._max_latency = self.get_last_value("{latency}.data".format(latency = latency_pre), ".*max-")#None # TBC
-            # support old typo
-            if self._max_latency is None:
-                latency_pre = "trex-latecny"
-                self._max_latency = self.get_last_value("{latency}.data".format(latency = latency_pre), ".*max-")
-
-            self._avg_latency = self.get_last_value("{latency}.data".format(latency = latency_pre), "avg-")#None # TBC
-            self._avg_latency = CTRexResult.__avg_all_and_rename_keys(self._avg_latency)
-
-            avg_win_latency_list     = self.get_value_list("{latency}.data".format(latency = latency_pre), "avg-")
-            self._avg_window_latency = CTRexResult.__calc_latency_win_stats(avg_win_latency_list)
+            if self.latency_checked:
+                latency_pre = "trex-latency"
+                self._max_latency = self.get_last_value("{latency}.data".format(latency = latency_pre), ".*max-")#None # TBC
+                # support old typo
+                if self._max_latency is None:
+                    latency_pre = "trex-latecny"
+                    self._max_latency = self.get_last_value("{latency}.data".format(latency = latency_pre), ".*max-")
+
+                self._avg_latency = self.get_last_value("{latency}.data".format(latency = latency_pre), "avg-")#None # TBC
+                self._avg_latency = CTRexResult.__avg_all_and_rename_keys(self._avg_latency)
+
+                avg_win_latency_list     = self.get_value_list("{latency}.data".format(latency = latency_pre), "avg-")
+                self._avg_window_latency = CTRexResult.__calc_latency_win_stats(avg_win_latency_list)
 
             tx_pkts = CTRexResult.__get_value_by_path(latest_dump, "trex-global.data.m_total_tx_pkts")
             rx_pkts = CTRexResult.__get_value_by_path(latest_dump, "trex-global.data.m_total_rx_pkts")
diff --git a/scripts/automation/trex_control_plane/client/trex_port.py b/scripts/automation/trex_control_plane/client/trex_port.py
new file mode 100644
index 00000000..54b4945e
--- /dev/null
+++ b/scripts/automation/trex_control_plane/client/trex_port.py
@@ -0,0 +1,430 @@
+
+from collections import namedtuple
+from common.trex_types import *
+from common import trex_stats
+
+
+########## utlity ############
+def mult_to_factor (mult, max_bps, max_pps, line_util):
+    if mult['type'] == 'raw':
+        return mult['value']
+
+    if mult['type'] == 'bps':
+        return mult['value'] / max_bps
+
+    if mult['type'] == 'pps':
+        return mult['value'] / max_pps
+
+    if mult['type'] == 'percentage':
+        return mult['value'] / line_util
+
+
+# describes a single port
+class Port(object):
+    STATE_DOWN       = 0
+    STATE_IDLE       = 1
+    STATE_STREAMS    = 2
+    STATE_TX         = 3
+    STATE_PAUSE      = 4
+    PortState = namedtuple('PortState', ['state_id', 'state_name'])
+    STATES_MAP = {STATE_DOWN: "DOWN",
+                  STATE_IDLE: "IDLE",
+                  STATE_STREAMS: "IDLE",
+                  STATE_TX: "ACTIVE",
+                  STATE_PAUSE: "PAUSE"}
+
+
+    def __init__ (self, port_id, speed, driver, user, comm_link, session_id):
+        self.port_id = port_id
+        self.state = self.STATE_IDLE
+        self.handler = None
+        self.comm_link = comm_link
+        self.transmit = comm_link.transmit
+        self.transmit_batch = comm_link.transmit_batch
+        self.user = user
+        self.driver = driver
+        self.speed = speed
+        self.streams = {}
+        self.profile = None
+        self.session_id = session_id
+
+        self.port_stats = trex_stats.CPortStats(self)
+
+
+    def err(self, msg):
+        return RC_ERR("port {0} : {1}".format(self.port_id, msg))
+
+    def ok(self, data = "ACK"):
+        return RC_OK(data)
+
+    def get_speed_bps (self):
+        return (self.speed * 1000 * 1000 * 1000)
+
+    # take the port
+    def acquire(self, force = False):
+        params = {"port_id":     self.port_id,
+                  "user":        self.user,
+                  "session_id":  self.session_id,
+                  "force":       force}
+
+        command = RpcCmdData("acquire", params)
+        rc = self.transmit(command.method, command.params)
+        if rc.good():
+            self.handler = rc.data()
+            return self.ok()
+        else:
+            return self.err(rc.err())
+
+    # release the port
+    def release(self):
+        params = {"port_id": self.port_id,
+                  "handler": self.handler}
+
+        command = RpcCmdData("release", params)
+        rc = self.transmit(command.method, command.params)
+        self.handler = None
+
+        if rc.good():
+            return self.ok()
+        else:
+            return self.err(rc.err())
+
+    def is_acquired(self):
+        return (self.handler != None)
+
+    def is_active(self):
+        return(self.state == self.STATE_TX ) or (self.state == self.STATE_PAUSE)
+
+    def is_transmitting (self):
+        return (self.state == self.STATE_TX)
+
+    def is_paused (self):
+        return (self.state == self.STATE_PAUSE)
+
+
+    def sync(self):
+        params = {"port_id": self.port_id}
+
+        command = RpcCmdData("get_port_status", params)
+        rc = self.transmit(command.method, command.params)
+        if rc.bad():
+            return self.err(rc.err())
+
+        # sync the port
+        port_state = rc.data()['state']
+
+        if port_state == "DOWN":
+            self.state = self.STATE_DOWN
+        elif port_state == "IDLE":
+            self.state = self.STATE_IDLE
+        elif port_state == "STREAMS":
+            self.state = self.STATE_STREAMS
+        elif port_state == "TX":
+            self.state = self.STATE_TX
+        elif port_state == "PAUSE":
+            self.state = self.STATE_PAUSE
+        else:
+            raise Exception("port {0}: bad state received from server '{1}'".format(self.port_id, sync_data['state']))
+
+        return self.ok()
+
+
+    # return TRUE if write commands
+    def is_port_writable (self):
+        # operations on port can be done on state idle or state streams
+        return ((self.state == self.STATE_IDLE) or (self.state == self.STATE_STREAMS))
+
+    # add stream to the port
+    def add_stream (self, stream_id, stream_obj):
+
+        if not self.is_port_writable():
+            return self.err("Please stop port before attempting to add streams")
+
+
+        params = {"handler": self.handler,
+                  "port_id": self.port_id,
+                  "stream_id": stream_id,
+                  "stream": stream_obj}
+
+        rc = self.transmit("add_stream", params)
+        if rc.bad():
+            return self.err(rc.err())
+
+        # add the stream
+        self.streams[stream_id] = stream_obj
+
+        # the only valid state now
+        self.state = self.STATE_STREAMS
+
+        return self.ok()
+
+    # add multiple streams
+    def add_streams (self, streams_list):
+        batch = []
+
+        for stream in streams_list:
+            params = {"handler": self.handler,
+                      "port_id": self.port_id,
+                      "stream_id": stream.stream_id,
+                      "stream": stream.stream}
+
+            cmd = RpcCmdData('add_stream', params)
+            batch.append(cmd)
+
+        rc = self.transmit_batch(batch)
+        if rc.bad():
+            return self.err(rc.err())
+
+        # validate that every action succeeded
+
+        # add the stream
+        for stream in streams_list:
+            self.streams[stream.stream_id] = stream.stream
+
+        # the only valid state now
+        self.state = self.STATE_STREAMS
+
+        return self.ok()
+
+    # remove stream from port
+    def remove_stream (self, stream_id):
+
+        if not stream_id in self.streams:
+            return self.err("stream {0} does not exists".format(stream_id))
+
+        params = {"handler": self.handler,
+                  "port_id": self.port_id,
+                  "stream_id": stream_id}
+
+
+        rc = self.transmit("remove_stream", params)
+        if rc.bad():
+            return self.err(rc.err())
+
+        self.streams[stream_id] = None
+
+        self.state = self.STATE_STREAMS if len(self.streams > 0) else self.STATE_IDLE
+
+        return self.ok()
+
+    # remove all the streams
+    def remove_all_streams (self):
+
+        params = {"handler": self.handler,
+                  "port_id": self.port_id}
+
+        rc = self.transmit("remove_all_streams", params)
+        if rc.bad():
+            return self.err(rc.err())
+
+        self.streams = {}
+
+        self.state = self.STATE_IDLE
+
+        return self.ok()
+
+    # get a specific stream
+    def get_stream (self, stream_id):
+        if stream_id in self.streams:
+            return self.streams[stream_id]
+        else:
+            return None
+
+    def get_all_streams (self):
+        return self.streams
+
+    # start traffic
+    def start (self, mul, duration):
+        if self.state == self.STATE_DOWN:
+            return self.err("Unable to start traffic - port is down")
+
+        if self.state == self.STATE_IDLE:
+            return self.err("Unable to start traffic - no streams attached to port")
+
+        if self.state == self.STATE_TX:
+            return self.err("Unable to start traffic - port is already transmitting")
+
+        params = {"handler": self.handler,
+                  "port_id": self.port_id,
+                  "mul": mul,
+                  "duration": duration}
+
+        rc = self.transmit("start_traffic", params)
+        if rc.bad():
+            return self.err(rc.err())
+
+        self.state = self.STATE_TX
+
+        return self.ok()
+
+    # stop traffic
+    # with force ignores the cached state and sends the command
+    def stop (self, force = False):
+
+        if (not force) and (self.state != self.STATE_TX) and (self.state != self.STATE_PAUSE):
+            return self.err("port is not transmitting")
+
+        params = {"handler": self.handler,
+                  "port_id": self.port_id}
+
+        rc = self.transmit("stop_traffic", params)
+        if rc.bad():
+            return self.err(rc.err())
+
+        # only valid state after stop
+        self.state = self.STATE_STREAMS
+
+        return self.ok()
+
+    def pause (self):
+
+        if (self.state != self.STATE_TX) :
+            return self.err("port is not transmitting")
+
+        params = {"handler": self.handler,
+                  "port_id": self.port_id}
+
+        rc  = self.transmit("pause_traffic", params)
+        if rc.bad():
+            return self.err(rc.err())
+
+        # only valid state after stop
+        self.state = self.STATE_PAUSE
+
+        return self.ok()
+
+
+    def resume (self):
+
+        if (self.state != self.STATE_PAUSE) :
+            return self.err("port is not in pause mode")
+
+        params = {"handler": self.handler,
+                  "port_id": self.port_id}
+
+        rc = self.transmit("resume_traffic", params)
+        if rc.bad():
+            return self.err(rc.err())
+
+        # only valid state after stop
+        self.state = self.STATE_TX
+
+        return self.ok()
+
+
+    def update (self, mul):
+        if (self.state != self.STATE_TX) :
+            return self.err("port is not transmitting")
+
+        params = {"handler": self.handler,
+                  "port_id": self.port_id,
+                  "mul": mul}
+
+        rc = self.transmit("update_traffic", params)
+        if rc.bad():
+            return self.err(rc.err())
+
+        return self.ok()
+
+
+    def validate (self):
+
+        if (self.state == self.STATE_DOWN):
+            return self.err("port is down")
+
+        if (self.state == self.STATE_IDLE):
+            return self.err("no streams attached to port")
+
+        params = {"handler": self.handler,
+                  "port_id": self.port_id}
+
+        rc = self.transmit("validate", params)
+        if rc.bad():
+            return self.err(rc.err())
+
+        self.profile = rc.data()
+
+        return self.ok()
+
+    def get_profile (self):
+        return self.profile
+
+
+    def print_profile (self, mult, duration):
+        if not self.get_profile():
+            return
+
+        rate = self.get_profile()['rate']
+        graph = self.get_profile()['graph']
+
+        print format_text("Profile Map Per Port\n", 'underline', 'bold')
+
+        factor = mult_to_factor(mult, rate['max_bps'], rate['max_pps'], rate['max_line_util'])
+
+        print "Profile max BPS    (base / req):   {:^12} / {:^12}".format(format_num(rate['max_bps'], suffix = "bps"),
+                                                                          format_num(rate['max_bps'] * factor, suffix = "bps"))
+
+        print "Profile max PPS    (base / req):   {:^12} / {:^12}".format(format_num(rate['max_pps'], suffix = "pps"),
+                                                                          format_num(rate['max_pps'] * factor, suffix = "pps"),)
+
+        print "Profile line util. (base / req):   {:^12} / {:^12}".format(format_percentage(rate['max_line_util'] * 100),
+                                                                          format_percentage(rate['max_line_util'] * factor * 100))
+
+
+        # duration
+        exp_time_base_sec = graph['expected_duration'] / (1000 * 1000)
+        exp_time_factor_sec = exp_time_base_sec / factor
+
+        # user configured a duration
+        if duration > 0:
+            if exp_time_factor_sec > 0:
+                exp_time_factor_sec = min(exp_time_factor_sec, duration)
+            else:
+                exp_time_factor_sec = duration
+
+
+        print "Duration           (base / req):   {:^12} / {:^12}".format(format_time(exp_time_base_sec),
+                                                                          format_time(exp_time_factor_sec))
+        print "\n"
+
+
+    def get_port_state_name(self):
+        return self.STATES_MAP.get(self.state, "Unknown")
+
+    ################# stats handler ######################
+    def generate_port_stats(self):
+        return self.port_stats.generate_stats()
+        pass
+
+    def generate_port_status(self):
+        return {"port-type": self.driver,
+                "maximum": "{speed} Gb/s".format(speed=self.speed),
+                "port-status": self.get_port_state_name()
+                }
+
+    def clear_stats(self):
+        return self.port_stats.clear_stats()
+
+    def invalidate_stats(self):
+        return self.port_stats.invalidate()
+
+
+    ################# events handler ######################
+    def async_event_port_stopped (self):
+        self.state = self.STATE_STREAMS
+
+
+    def async_event_port_started (self):
+        self.state = self.STATE_TX
+
+
+    def async_event_port_paused (self):
+        self.state = self.STATE_PAUSE
+
+
+    def async_event_port_resumed (self):
+        self.state = self.STATE_TX
+
+    def async_event_forced_acquired (self):
+        self.handler = None
+
diff --git a/scripts/automation/trex_control_plane/client/trex_stateless_client.py b/scripts/automation/trex_control_plane/client/trex_stateless_client.py
index 748817da..58fa53c9 100755
--- a/scripts/automation/trex_control_plane/client/trex_stateless_client.py
+++ b/scripts/automation/trex_control_plane/client/trex_stateless_client.py
@@ -14,433 +14,40 @@ import json
 from common.trex_streams import *
 from collections import namedtuple
 from common.text_opts import *
-# import trex_stats
 from common import trex_stats
 from client_utils import parsing_opts, text_tables
 import time
 import datetime
 import re
+import random
+from trex_port import Port
+from common.trex_types import *
 
 from trex_async_client import CTRexAsyncClient
 
-RpcCmdData = namedtuple('RpcCmdData', ['method', 'params'])
 
-class RpcResponseStatus(namedtuple('RpcResponseStatus', ['success', 'id', 'msg'])):
-        __slots__ = ()
-        def __str__(self):
-            return "{id:^3} - {msg} ({stat})".format(id=self.id,
-                                                  msg=self.msg,
-                                                  stat="success" if self.success else "fail")
-
-# simple class to represent complex return value
-class RC():
-
-    def __init__ (self, rc = None, data = None):
-        self.rc_list = []
-
-        if (rc != None) and (data != None):
-            tuple_rc = namedtuple('RC', ['rc', 'data'])
-            self.rc_list.append(tuple_rc(rc, data))
-
-    def add (self, rc):
-        self.rc_list += rc.rc_list
-
-    def good (self):
-        return all([x.rc for x in self.rc_list])
-
-    def bad (self):
-        return not self.good()
-
-    def data (self):
-        return all([x.data if x.rc else "" for x in self.rc_list])
-
-    def err (self):
-        return all([x.data if not x.rc else "" for x in self.rc_list])
-
-    def annotate (self, desc = None):
-        if desc:
-            print format_text('\n{:<40}'.format(desc), 'bold'),
-
-        if self.bad():
-            # print all the errors
-            print ""
-            for x in self.rc_list:
-                if not x.rc:
-                    print format_text("\n{0}".format(x.data), 'bold')
-
-            print ""
-            print format_text("[FAILED]\n", 'red', 'bold')
-
-
-        else:
-            print format_text("[SUCCESS]\n", 'green', 'bold')
-
-
-def RC_OK():
-    return RC(True, "")
-def RC_ERR(err):
-    return RC(False, err)
-
-
-LoadedStreamList = namedtuple('LoadedStreamList', ['loaded', 'compiled'])
-
-# describes a stream DB
-class CStreamsDB(object):
-
-    def __init__(self):
-        self.stream_packs = {}
-
-    def load_yaml_file(self, filename):
-
-        stream_pack_name = filename
-        if stream_pack_name in self.get_loaded_streams_names():
-            self.remove_stream_packs(stream_pack_name)
-
-        stream_list = CStreamList()
-        loaded_obj = stream_list.load_yaml(filename)
-
-        try:
-            compiled_streams = stream_list.compile_streams()
-            rc = self.load_streams(stream_pack_name,
-                                   LoadedStreamList(loaded_obj,
-                                                    [StreamPack(v.stream_id, v.stream.dump())
-                                                     for k, v in compiled_streams.items()]))
-
-        except Exception as e:
-            return None
-
-        return self.get_stream_pack(stream_pack_name)
-
-    def load_streams(self, name, LoadedStreamList_obj):
-        if name in self.stream_packs:
-            return False
-        else:
-            self.stream_packs[name] = LoadedStreamList_obj
-            return True
-
-    def remove_stream_packs(self, *names):
-        removed_streams = []
-        for name in names:
-            removed = self.stream_packs.pop(name)
-            if removed:
-                removed_streams.append(name)
-        return removed_streams
-
-    def clear(self):
-        self.stream_packs.clear()
-
-    def get_loaded_streams_names(self):
-        return self.stream_packs.keys()
-
-    def stream_pack_exists (self, name):
-        return name in self.get_loaded_streams_names()
-
-    def get_stream_pack(self, name):
-        if not self.stream_pack_exists(name):
-            return None
-        else:
-            return self.stream_packs.get(name)
-
-
-# describes a single port
-class Port(object):
-    STATE_DOWN       = 0
-    STATE_IDLE       = 1
-    STATE_STREAMS    = 2
-    STATE_TX         = 3
-    STATE_PAUSE      = 4
-    PortState = namedtuple('PortState', ['state_id', 'state_name'])
-    STATES_MAP = {STATE_DOWN: "DOWN",
-                  STATE_IDLE: "IDLE",
-                  STATE_STREAMS: "STREAMS",
-                  STATE_TX: "ACTIVE",
-                  STATE_PAUSE: "PAUSE"}
-
-
-    def __init__ (self, port_id, speed, driver, user, transmit):
-        self.port_id = port_id
-        self.state = self.STATE_IDLE
-        self.handler = None
-        self.transmit = transmit
-        self.user = user
-        self.driver = driver
-        self.speed = speed
-        self.streams = {}
-        self.port_stats = trex_stats.CPortStats(self)
-
-    def err(self, msg):
-        return RC_ERR("port {0} : {1}".format(self.port_id, msg))
-
-    def ok(self):
-        return RC_OK()
-
-    def get_speed_bps (self):
-        return (self.speed * 1000 * 1000 * 1000)
-
-    # take the port
-    def acquire(self, force = False):
-        params = {"port_id": self.port_id,
-                  "user":    self.user,
-                  "force":   force}
-
-        command = RpcCmdData("acquire", params)
-        rc = self.transmit(command.method, command.params)
-        if rc.success:
-            self.handler = rc.data
-            return self.ok()
-        else:
-            return self.err(rc.data)
-
-    # release the port
-    def release(self):
-        params = {"port_id": self.port_id,
-                  "handler": self.handler}
-
-        command = RpcCmdData("release", params)
-        rc = self.transmit(command.method, command.params)
-        if rc.success:
-            self.handler = rc.data
-            return self.ok()
-        else:
-            return self.err(rc.data)
-
-    def is_acquired(self):
-        return (self.handler != None)
-
-    def is_active(self):
-        return(self.state == self.STATE_TX ) or (self.state == self.STATE_PAUSE)
-
-    def sync(self, sync_data):
-        self.handler = sync_data['handler']
-        port_state = sync_data['state'].upper()
-        if port_state == "DOWN":
-            self.state = self.STATE_DOWN
-        elif port_state == "IDLE":
-            self.state = self.STATE_IDLE
-        elif port_state == "STREAMS":
-            self.state = self.STATE_STREAMS
-        elif port_state == "TX":
-            self.state = self.STATE_TX
-        elif port_state == "PAUSE":
-            self.state = self.STATE_PAUSE
-        else:
-            raise Exception("port {0}: bad state received from server '{1}'".format(self.port_id, sync_data['state']))
-
-        return self.ok()
-        
-
-    # return TRUE if write commands
-    def is_port_writable (self):
-        # operations on port can be done on state idle or state streams
-        return ((self.state == self.STATE_IDLE) or (self.state == self.STATE_STREAMS))
-
-    # add stream to the port
-    def add_stream (self, stream_id, stream_obj):
-
-        if not self.is_port_writable():
-            return self.err("Please stop port before attempting to add streams")
-
-
-        params = {"handler": self.handler,
-                  "port_id": self.port_id,
-                  "stream_id": stream_id,
-                  "stream": stream_obj}
-
-        rc, data = self.transmit("add_stream", params)
-        if not rc:
-            r = self.err(data)
-            print r.good()
-
-        # add the stream
-        self.streams[stream_id] = stream_obj
-
-        # the only valid state now
-        self.state = self.STATE_STREAMS
-
-        return self.ok()
-
-    # remove stream from port
-    def remove_stream (self, stream_id):
-
-        if not stream_id in self.streams:
-            return self.err("stream {0} does not exists".format(stream_id))
-
-        params = {"handler": self.handler,
-                  "port_id": self.port_id,
-                  "stream_id": stream_id}
-                  
-
-        rc, data = self.transmit("remove_stream", params)
-        if not rc:
-            return self.err(data)
-
-        self.streams[stream_id] = None
-
-        return self.ok()
-
-    # remove all the streams
-    def remove_all_streams (self):
-
-        params = {"handler": self.handler,
-                  "port_id": self.port_id}
+class CTRexStatelessClient(object):
+    """docstring for CTRexStatelessClient"""
 
-        rc, data = self.transmit("remove_all_streams", params)
-        if not rc:
-            return self.err(data)
+    # verbose levels
+    VERBOSE_QUIET = 0
+    VERBOSE_REGULAR = 1
+    VERBOSE_HIGH    = 2
+    
+    def __init__(self, username, server="localhost", sync_port = 5050, async_port = 4500, quiet = False, virtual = False):
+        super(CTRexStatelessClient, self).__init__()
 
-        self.streams = {}
+        self.user = username
 
-        return self.ok()
+        self.comm_link = CTRexStatelessClient.CCommLink(server, sync_port, virtual, self.prn_func)
 
-    # get a specific stream
-    def get_stream (self, stream_id):
-        if stream_id in self.streams:
-            return self.streams[stream_id]
+        # default verbose level
+        if not quiet:
+            self.verbose = self.VERBOSE_REGULAR
         else:
-            return None
-
-    def get_all_streams (self):
-        return self.streams
-
-
-    def process_mul (self, mul):
-        # if percentage - translate 
-        if mul['type'] == 'percentage':
-            mul['type'] = 'max_bps'
-            mul['max']  = self.get_speed_bps() * (mul['max'] / 100)
-
-
-    # start traffic
-    def start (self, mul, duration):
-        if self.state == self.STATE_DOWN:
-            return self.err("Unable to start traffic - port is down")
-
-        if self.state == self.STATE_IDLE:
-            return self.err("Unable to start traffic - no streams attached to port")
-
-        if self.state == self.STATE_TX:
-            return self.err("Unable to start traffic - port is already transmitting")
-
-        self.process_mul(mul)
-         
-        params = {"handler": self.handler,
-                  "port_id": self.port_id,
-                  "mul": mul,
-                  "duration": duration}
-
-        rc, data = self.transmit("start_traffic", params)
-        if not rc:
-            return self.err(data)
-
-        self.state = self.STATE_TX
-
-        return self.ok()
-
-    # stop traffic
-    # with force ignores the cached state and sends the command
-    def stop (self, force = False):
-
-        if (not force) and (self.state != self.STATE_TX) and (self.state != self.STATE_PAUSE):
-            return self.err("port is not transmitting")
-
-        params = {"handler": self.handler,
-                  "port_id": self.port_id}
-
-        rc, data = self.transmit("stop_traffic", params)
-        if not rc:
-            return self.err(data)
-
-        # only valid state after stop
-        self.state = self.STATE_STREAMS
-
-        return self.ok()
-
-    def pause (self):
-
-        if (self.state != self.STATE_TX) :
-            return self.err("port is not transmitting")
-
-        params = {"handler": self.handler,
-                  "port_id": self.port_id}
+            self.verbose = self.VERBOSE_QUIET
 
-        rc, data = self.transmit("pause_traffic", params)
-        if not rc:
-            return self.err(data)
-
-        # only valid state after stop
-        self.state = self.STATE_PAUSE
-
-        return self.ok()
-
-
-    def resume (self):
-
-        if (self.state != self.STATE_PAUSE) :
-            return self.err("port is not in pause mode")
-
-        params = {"handler": self.handler,
-                  "port_id": self.port_id}
-
-        rc, data = self.transmit("resume_traffic", params)
-        if not rc:
-            return self.err(data)
-
-        # only valid state after stop
-        self.state = self.STATE_TX
-
-        return self.ok()
-
-
-    def update (self, mul):
-        if (self.state != self.STATE_TX) :
-            return self.err("port is not transmitting")
-
-        self.process_mul(mul)
-
-        params = {"handler": self.handler,
-                  "port_id": self.port_id,
-                  "mul": mul}
-
-        rc, data = self.transmit("update_traffic", params)
-        if not rc:
-            return self.err(data)
-
-        return self.ok()
-
-    def get_port_state_name(self):
-        return self.STATES_MAP.get(self.state, "Unknown")
-
-    ################# stats handler ######################
-    def generate_port_stats(self):
-        return self.port_stats.generate_stats()
-        pass
-
-    def generate_port_status(self):
-        return {"port-type": self.driver,
-                "maximum": "{speed} Gb/s".format(speed=self.speed),
-                "port-status": self.get_port_state_name()
-                }
-
-    def clear_stats(self):
-        return self.port_stats.clear_stats()
-
-    ################# events handler ######################
-    def async_event_port_stopped (self):
-        self.state = self.STATE_STREAMS
-
-
-class CTRexStatelessClient(object):
-    """docstring for CTRexStatelessClient"""
-
-    def __init__(self, username, server="localhost", sync_port = 5050, async_port = 4500, virtual=False):
-        super(CTRexStatelessClient, self).__init__()
-        self.user = username
-        self.system_info = None
-        self.comm_link = CTRexStatelessClient.CCommLink(server, sync_port, virtual)
-        self.verbose = False
         self.ports = {}
-        # self._conn_handler = {}
-        # self._active_ports = set()
         self._connection_info = {"server": server,
                                  "sync_port": sync_port,
                                  "async_port": async_port}
@@ -448,7 +55,7 @@ class CTRexStatelessClient(object):
         self.server_version = {}
         self.__err_log = None
 
-        self._async_client = CTRexAsyncClient(server, async_port, self)
+        self.async_client = CTRexAsyncClient(server, async_port, self, self.prn_func)
 
         self.streams_db = CStreamsDB()
         self.global_stats = trex_stats.CGlobalStats(self._connection_info,
@@ -457,12 +64,44 @@ class CTRexStatelessClient(object):
         self.stats_generator = trex_stats.CTRexStatsGenerator(self.global_stats,
                                                               self.ports)
 
+        self.events = []
+
+        self.session_id = random.getrandbits(32)
+        self.read_only = False
         self.connected = False
 
-        self.events = []
+
+
+    # returns the port object
+    def get_port (self, port_id):
+        return self.ports.get(port_id, None)
+
+
+    # connection server ip
+    def get_server_ip (self):
+        return self.comm_link.get_server()
+
+    # connection server port
+    def get_server_port (self):
+        return self.comm_link.get_port()
+
 
     ################# events handler ######################
-  
+    def add_event_log (self, msg, ev_type, show = False):
+
+        if ev_type == "server":
+            prefix = "[server]"
+        elif ev_type == "local":
+            prefix = "[local]"
+
+        ts = time.time()
+        st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
+        self.events.append("{:<10} - {:^8} - {:}".format(st, prefix, format_text(msg, 'bold')))
+
+        if show:
+            self.prn_func(format_text("\n{:^8} - {:}".format(prefix, format_text(msg, 'bold'))))
+        
+
     def handle_async_stats_update(self, dump_data):
         global_stats = {}
         port_stats = {}
@@ -490,59 +129,108 @@ class CTRexStatelessClient(object):
         for port_id, data in port_stats.iteritems():
             self.ports[port_id].port_stats.update(data)
 
+
+
     def handle_async_event (self, type, data):
         # DP stopped
 
-        ev = "[event] - "
-
         show_event = False
 
         # port started
         if (type == 0):
             port_id = int(data['port_id'])
-            ev += "Port {0} has started".format(port_id)
+            ev = "Port {0} has started".format(port_id)
+            self.async_event_port_started(port_id)
 
         # port stopped
         elif (type == 1):
             port_id = int(data['port_id'])
-            ev += "Port {0} has stopped".format(port_id)
+            ev = "Port {0} has stopped".format(port_id)
 
             # call the handler
             self.async_event_port_stopped(port_id)
             
 
-        # server stopped
+        # port paused
         elif (type == 2):
-            ev += "Server has stopped"
-            self.async_event_server_stopped()
-            show_event = True
+            port_id = int(data['port_id'])
+            ev = "Port {0} has paused".format(port_id)
 
-        # port finished traffic
+            # call the handler
+            self.async_event_port_paused(port_id)
+
+        # port resumed
         elif (type == 3):
             port_id = int(data['port_id'])
-            ev += "Port {0} job done".format(port_id)
+            ev = "Port {0} has resumed".format(port_id)
+
+            # call the handler
+            self.async_event_port_resumed(port_id)
+
+        # port finished traffic
+        elif (type == 4):
+            port_id = int(data['port_id'])
+            ev = "Port {0} job done".format(port_id)
 
             # call the handler
             self.async_event_port_stopped(port_id)
             show_event = True
 
+        # port was stolen...
+        elif (type == 5):
+            session_id = data['session_id']
+
+            # false alarm, its us
+            if session_id == self.session_id:
+                return
+
+            port_id = int(data['port_id'])
+            who = data['who']
+
+            ev = "Port {0} was forcely taken by '{1}'".format(port_id, who)
+
+            # call the handler
+            self.async_event_port_forced_acquired(port_id)
+            show_event = True
+
+        # server stopped
+        elif (type == 100):
+            ev = "Server has stopped"
+            self.async_event_server_stopped()
+            show_event = True
+
+
         else:
             # unknown event - ignore
             return
 
-        if show_event:
-            print format_text("\n" + ev, 'bold')
 
-        ts = time.time()
-        st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
-        self.events.append("{0} - ".format(st) + format_text(ev, 'bold'))
+        self.add_event_log(ev, 'server', show_event)
 
 
     def async_event_port_stopped (self, port_id):
         self.ports[port_id].async_event_port_stopped()
 
+
+    def async_event_port_started (self, port_id):
+        self.ports[port_id].async_event_port_started()
+
+    
+    def async_event_port_paused (self, port_id):
+        self.ports[port_id].async_event_port_paused()
+
+
+    def async_event_port_resumed (self, port_id):
+        self.ports[port_id].async_event_port_resumed()
+
+
+    def async_event_port_forced_acquired (self, port_id):
+        self.ports[port_id].async_event_forced_acquired()
+        self.read_only = True
+
     def async_event_server_stopped (self):
-        self.disconnect()
+        self.connected = False
+
 
     def get_events (self):
         return self.events
@@ -552,6 +240,24 @@ class CTRexStatelessClient(object):
 
     ############# helper functions section ##############
 
+    # measure time for functions
+    def timing(f):
+        def wrap(*args):
+            time1 = time.time()
+            ret = f(*args)
+
+            # don't want to print on error
+            if ret.bad():
+                return ret
+
+            delta = time.time() - time1
+            print format_time(delta) + "\n"
+
+            return ret
+
+        return wrap
+
+
     def validate_port_list(self, port_id_list):
         if not isinstance(port_id_list, list):
             print type(port_id_list)
@@ -584,66 +290,120 @@ class CTRexStatelessClient(object):
     ############ boot up section ################
 
     # connection sequence
-    def connect(self):
 
+    # mode can be RW - read / write, RWF - read write with force , RO - read only
+    def connect(self, mode = "RW"):
+
+        if self.is_connected():
+            self.disconnect()
+
+        # clear this flag
         self.connected = False
 
-        # connect
-        rc, data = self.comm_link.connect()
-        if not rc:
-            return RC_ERR(data)
+        # connect sync channel
+        rc = self.comm_link.connect()
+        if rc.bad():
+            return rc
+
+        # connect async channel
+        rc = self.async_client.connect()
+        if rc.bad():
+            return rc
 
         # version
-        rc, data = self.transmit("get_version")
-        if not rc:
-            return RC_ERR(data)
+        rc = self.transmit("get_version")
+        if rc.bad():
+            return rc
 
-        self.server_version = data
-        self.global_stats.server_version = data
+        self.server_version = rc.data()
+        self.global_stats.server_version = rc.data()
 
         # cache system info
-        # self.get_system_info(refresh=True)
-        rc, data = self.transmit("get_system_info")
-        if not rc:
-            return RC_ERR(data)
-        self.system_info = data
+        rc = self.transmit("get_system_info")
+        if rc.bad():
+            return rc
+
+        self.system_info = rc.data()
 
         # cache supported commands
-        rc, data = self.transmit("get_supported_cmds")
-        if not rc:
-            return RC_ERR(data)
+        rc = self.transmit("get_supported_cmds")
+        if rc.bad():
+            return rc
 
-        self.supported_cmds = data
+        self.supported_cmds = rc.data()
 
         # create ports
         for port_id in xrange(self.get_port_count()):
             speed = self.system_info['ports'][port_id]['speed']
             driver = self.system_info['ports'][port_id]['driver']
-            self.ports[port_id] = Port(port_id, speed, driver, self.user, self.transmit)
 
-        # acquire all ports
-        rc = self.acquire()
-        if rc.bad():
-            return rc
+            self.ports[port_id] = Port(port_id, speed, driver, self.user, self.comm_link, self.session_id)
+
 
-        rc = self.sync_with_server()
+        # sync the ports
+        rc = self.sync_ports()
         if rc.bad():
             return rc
 
-        self.connected = True
+        # acquire all ports
+        if mode == "RW":
+            rc = self.acquire(force = False)
+
+            # fallback to read only if failed
+            if rc.bad():
+                rc.annotate(show_status = False)
+                print format_text("Switching to read only mode - only few commands will be available", 'bold')
+
+                self.release(self.get_acquired_ports())
+                self.read_only = True
+            else:
+                self.read_only = False
+
+        elif mode == "RWF":
+            rc = self.acquire(force = True)
+            if rc.bad():
+                return rc
+            self.read_only = False
 
+        elif mode == "RO":
+            # no acquire on read only
+            rc = RC_OK()
+            self.read_only = True
+
+
+        
+        self.connected = True
         return RC_OK()
 
+
+    def is_read_only (self):
+        return self.read_only
+
     def is_connected (self):
         return self.connected and self.comm_link.is_connected
 
 
     def disconnect(self):
-        self.connected = False
+        # release any previous acquired ports
+        if self.is_connected():
+            self.release(self.get_acquired_ports())
+
         self.comm_link.disconnect()
+        self.async_client.disconnect()
+
+        self.connected = False
+
         return RC_OK()
 
 
+    def on_async_dead (self):
+        if self.connected:
+            msg = 'lost connection to server'
+            self.add_event_log(msg, 'local', True)
+            self.connected = False
+
+    def on_async_alive (self):
+        pass
 
     ########### cached queries (no server traffic) ###########
 
@@ -666,8 +426,8 @@ class CTRexStatelessClient(object):
         else:
             return port_ids
 
-    def get_stats_async(self):
-        return self._async_client.get_stats()
+    def get_stats_async (self):
+        return self.async_client.get_stats()
 
     def get_connection_port (self):
         return self.comm_link.port
@@ -675,6 +435,9 @@ class CTRexStatelessClient(object):
     def get_connection_ip (self):
         return self.comm_link.server
 
+    def get_all_ports (self):
+        return [port_id for port_id, port_obj in self.ports.iteritems()]
+
     def get_acquired_ports(self):
         return [port_id
                 for port_id, port_obj in self.ports.iteritems()
@@ -685,36 +448,60 @@ class CTRexStatelessClient(object):
                 for port_id, port_obj in self.ports.iteritems()
                 if port_obj.is_active()]
 
+    def get_paused_ports (self):
+        return [port_id
+                for port_id, port_obj in self.ports.iteritems()
+                if port_obj.is_paused()]
+
+    def get_transmitting_ports (self):
+        return [port_id
+                for port_id, port_obj in self.ports.iteritems()
+                if port_obj.is_transmitting()]
+
     def set_verbose(self, mode):
-        self.comm_link.set_verbose(mode)
+
+        # on high - enable link verbose
+        if mode == self.VERBOSE_HIGH:
+            self.comm_link.set_verbose(True)
+        else:
+            self.comm_link.set_verbose(False)
+
         self.verbose = mode
 
+
+    def check_verbose (self, level):
+        return (self.verbose >= level)
+
+    def get_verbose (self):
+        return self.verbose
+
+    def prn_func (self, msg, level = VERBOSE_REGULAR):
+        if self.check_verbose(level):
+            print msg
+
     ############# server actions ################
 
     # ping server
     def ping(self):
-        rc, info = self.transmit("ping")
-        return RC(rc, info)
+        return self.transmit("ping")
 
 
-    def sync_with_server(self, sync_streams=False):
-        rc, data = self.transmit("sync_user", {"user": self.user, "sync_streams": sync_streams})
-        if not rc:
-            return RC_ERR(data)
-
-        for port_info in data:
-            rc = self.ports[port_info['port_id']].sync(port_info)
-            if rc.bad():
-                return rc
-
-        return RC_OK()
 
     def get_global_stats(self):
-        rc, info = self.transmit("get_global_stats")
-        return RC(rc, info)
+        return self.transmit("get_global_stats")
 
 
     ########## port commands ##############
+    def sync_ports (self, port_id_list = None, force = False):
+        port_id_list = self.__ports(port_id_list)
+
+        rc = RC()
+
+        for port_id in port_id_list:
+            rc.add(self.ports[port_id].sync())
+     
+        return rc
+
     # acquire ports, if port_list is none - get all
     def acquire (self, port_id_list = None, force = False):
         port_id_list = self.__ports(port_id_list)
@@ -733,7 +520,7 @@ class CTRexStatelessClient(object):
         rc = RC()
 
         for port_id in port_id_list:
-            rc.add(self.ports[port_id].release(force))
+            rc.add(self.ports[port_id].release())
         
         return rc
 
@@ -750,15 +537,16 @@ class CTRexStatelessClient(object):
         return rc
 
       
+
     def add_stream_pack(self, stream_pack_list, port_id_list = None):
 
         port_id_list = self.__ports(port_id_list)
 
         rc = RC()
 
-        for stream_pack in stream_pack_list:
-            rc.add(self.add_stream(stream_pack.stream_id, stream_pack.stream, port_id_list))
-        
+        for port_id in port_id_list:
+            rc.add(self.ports[port_id].add_streams(stream_pack_list))
+
         return rc
 
 
@@ -855,6 +643,17 @@ class CTRexStatelessClient(object):
         return rc
 
 
+    def validate (self, port_id_list = None):
+        port_id_list = self.__ports(port_id_list)
+
+        rc = RC()
+
+        for port_id in port_id_list:
+            rc.add(self.ports[port_id].validate())
+     
+        return rc
+
+
     def get_port_stats(self, port_id=None):
         pass
 
@@ -866,16 +665,19 @@ class CTRexStatelessClient(object):
         return self.comm_link.transmit(method_name, params)
 
 
+    def transmit_batch(self, batch_list):
+        return self.comm_link.transmit_batch(batch_list)
 
     ######################### Console (high level) API #########################
 
+    @timing
     def cmd_ping(self):
         rc = self.ping()
         rc.annotate("Pinging the server on '{0}' port '{1}': ".format(self.get_connection_ip(), self.get_connection_port()))
         return rc
 
-    def cmd_connect(self):
-        rc = self.connect()
+    def cmd_connect(self, mode = "RW"):
+        rc = self.connect(mode)
         rc.annotate()
         return rc
 
@@ -886,13 +688,7 @@ class CTRexStatelessClient(object):
 
     # reset
     def cmd_reset(self):
-
-
-        # sync with the server
-        rc = self.sync_with_server()
-        rc.annotate("Syncing with the server:")
-        if rc.bad():
-            return rc
+        #self.release(self.get_acquired_ports())
 
         rc = self.acquire(force = True)
         rc.annotate("Force acquiring all ports:")
@@ -924,7 +720,7 @@ class CTRexStatelessClient(object):
         active_ports = list(set(self.get_active_ports()).intersection(port_id_list))
 
         if not active_ports:
-            msg = "No active traffic on porvided ports"
+            msg = "No active traffic on provided ports"
             print format_text(msg, 'bold')
             return RC_ERR(msg)
 
@@ -948,15 +744,26 @@ class CTRexStatelessClient(object):
 
         rc = self.update_traffic(mult, active_ports)
         rc.annotate("Updating traffic on port(s) {0}:".format(port_id_list))
-        if rc.bad():
-            return rc
 
-        return RC_OK()
+        return rc
 
+    # clear stats
     def cmd_clear(self, port_id_list):
+
         for port_id in port_id_list:
             self.ports[port_id].clear_stats()
+
         self.global_stats.clear_stats()
+
+        return RC_OK()
+
+
+    def cmd_invalidate (self, port_id_list):
+        for port_id in port_id_list:
+            self.ports[port_id].invalidate_stats()
+
+        self.global_stats.invalidate()
+
         return RC_OK()
 
     # pause cmd
@@ -972,10 +779,8 @@ class CTRexStatelessClient(object):
 
         rc = self.pause_traffic(active_ports)
         rc.annotate("Pausing traffic on port(s) {0}:".format(port_id_list))
-        if rc.bad():
-            return rc
+        return rc
 
-        return RC_OK()
 
 
     # resume cmd
@@ -991,14 +796,11 @@ class CTRexStatelessClient(object):
 
         rc = self.resume_traffic(active_ports)
         rc.annotate("Resume traffic on port(s) {0}:".format(port_id_list))
-        if rc.bad():
-            return rc
-
-        return RC_OK()
+        return rc
 
 
     # start cmd
-    def cmd_start (self, port_id_list, stream_list, mult, force, duration):
+    def cmd_start (self, port_id_list, stream_list, mult, force, duration, dry):
 
         active_ports = list(set(self.get_active_ports()).intersection(port_id_list))
 
@@ -1020,19 +822,37 @@ class CTRexStatelessClient(object):
 
 
         rc = self.add_stream_pack(stream_list.compiled, port_id_list)
-        rc.annotate("Attaching streams to port(s) {0}:".format(port_id_list))
+        rc.annotate("Attaching {0} streams to port(s) {1}:".format(len(stream_list.compiled), port_id_list))
         if rc.bad():
             return rc
 
+        # when not on dry - start the traffic , otherwise validate only
+        if not dry:
+            rc = self.start_traffic(mult, duration, port_id_list)
+            rc.annotate("Starting traffic on port(s) {0}:".format(port_id_list))
 
-        # finally, start the traffic
-        rc = self.start_traffic(mult, duration, port_id_list)
-        rc.annotate("Starting traffic on port(s) {0}:".format(port_id_list))
-        if rc.bad():
             return rc
+        else:
+            rc = self.validate(port_id_list)
+            rc.annotate("Validating traffic profile on port(s) {0}:".format(port_id_list))
 
-        return RC_OK()
+            if rc.bad():
+                return rc
 
+            # show a profile on one port for illustration
+            self.ports[port_id_list[0]].print_profile(mult, duration)
+
+            return rc
+
+
+    # validate port(s) profile
+    def cmd_validate (self, port_id_list):
+        rc = self.validate(port_id_list)
+        rc.annotate("Validating streams on port(s) {0}:".format(port_id_list))
+        return rc
+
+
+    # stats
     def cmd_stats(self, port_id_list, stats_mask=set()):
         stats_opts = trex_stats.ALL_STATS_OPTS.intersection(stats_mask)
 
@@ -1043,6 +863,26 @@ class CTRexStatelessClient(object):
 
 
     ############## High Level API With Parser ################
+
+    def cmd_connect_line (self, line):
+        '''Connects to the TRex server'''
+        # define a parser
+        parser = parsing_opts.gen_parser(self,
+                                         "connect",
+                                         self.cmd_connect_line.__doc__,
+                                         parsing_opts.FORCE)
+
+        opts = parser.parse_args(line.split())
+
+        if opts is None:
+            return RC_ERR("bad command line parameters")
+
+        if opts.force:
+            rc = self.cmd_connect(mode = "RWF")
+        else:
+            rc = self.cmd_connect(mode = "RW")
+
+    @timing
     def cmd_start_line (self, line):
         '''Start selected traffic in specified ports on TRex\n'''
         # define a parser
@@ -1054,13 +894,19 @@ class CTRexStatelessClient(object):
                                          parsing_opts.FORCE,
                                          parsing_opts.STREAM_FROM_PATH_OR_FILE,
                                          parsing_opts.DURATION,
-                                         parsing_opts.MULTIPLIER)
+                                         parsing_opts.MULTIPLIER_STRICT,
+                                         parsing_opts.DRY_RUN)
 
         opts = parser.parse_args(line.split())
 
+
         if opts is None:
             return RC_ERR("bad command line parameters")
 
+
+        if opts.dry:
+            print format_text("\n*** DRY RUN ***", 'bold')
+
         if opts.db:
             stream_list = self.streams_db.get_stream_pack(opts.db)
             rc = RC(stream_list != None)
@@ -1070,7 +916,15 @@ class CTRexStatelessClient(object):
 
         else:
             # load streams from file
-            stream_list = self.streams_db.load_yaml_file(opts.file[0])
+            stream_list = None;
+            try:
+              stream_list = self.streams_db.load_yaml_file(opts.file[0])
+            except Exception as e:
+                s = str(e)
+                rc=RC_ERR(s)
+                rc.annotate()
+                return rc
+
             rc = RC(stream_list != None)
             rc.annotate("Load stream pack (from file):")
             if stream_list == None:
@@ -1078,12 +932,13 @@ class CTRexStatelessClient(object):
 
 
         # total has no meaning with percentage - its linear
-        if opts.total and (mult['type'] != 'percentage'):
+        if opts.total and (opts.mult['type'] != 'percentage'):
             # if total was set - divide it between the ports
-            opts.mult['max'] = opts.mult['max'] / len(opts.ports)
+            opts.mult['value'] = opts.mult['value'] / len(opts.ports)
 
-        return self.cmd_start(opts.ports, stream_list, opts.mult, opts.force, opts.duration)
+        return self.cmd_start(opts.ports, stream_list, opts.mult, opts.force, opts.duration, opts.dry)
 
+    @timing
     def cmd_resume_line (self, line):
         '''Resume active traffic in specified ports on TRex\n'''
         parser = parsing_opts.gen_parser(self,
@@ -1097,6 +952,8 @@ class CTRexStatelessClient(object):
 
         return self.cmd_resume(opts.ports)
 
+
+    @timing
     def cmd_stop_line (self, line):
         '''Stop active traffic in specified ports on TRex\n'''
         parser = parsing_opts.gen_parser(self,
@@ -1110,6 +967,8 @@ class CTRexStatelessClient(object):
 
         return self.cmd_stop(opts.ports)
 
+
+    @timing
     def cmd_pause_line (self, line):
         '''Pause active traffic in specified ports on TRex\n'''
         parser = parsing_opts.gen_parser(self,
@@ -1123,6 +982,8 @@ class CTRexStatelessClient(object):
 
         return self.cmd_pause(opts.ports)
 
+
+    @timing
     def cmd_update_line (self, line):
         '''Update port(s) speed currently active\n'''
         parser = parsing_opts.gen_parser(self,
@@ -1139,14 +1000,15 @@ class CTRexStatelessClient(object):
         # total has no meaning with percentage - its linear
         if opts.total and (opts.mult['type'] != 'percentage'):
             # if total was set - divide it between the ports
-            opts.mult['max'] = opts.mult['max'] / len(opts.ports)
+            opts.mult['value'] = opts.mult['value'] / len(opts.ports)
 
         return self.cmd_update(opts.ports, opts.mult)
 
-
+    @timing
     def cmd_reset_line (self, line):
         return self.cmd_reset()
 
+
     def cmd_clear_line (self, line):
         '''Clear cached local statistics\n'''
         # define a parser
@@ -1161,6 +1023,7 @@ class CTRexStatelessClient(object):
             return RC_ERR("bad command line parameters")
         return self.cmd_clear(opts.ports)
 
+
     def cmd_stats_line (self, line):
         '''Fetch statistics from TRex server by port\n'''
         # define a parser
@@ -1180,30 +1043,34 @@ class CTRexStatelessClient(object):
         if not mask:
             # set to show all stats if no filter was given
             mask = trex_stats.ALL_STATS_OPTS
-        # get stats objects, as dictionary
+
         stats = self.cmd_stats(opts.ports, mask)
+
         # print stats to screen
         for stat_type, stat_data in stats.iteritems():
             text_tables.print_table_with_header(stat_data.text_table, stat_type)
-        return
-
-        # if opts.db:
-        #     stream_list = self.streams_db.get_stream_pack(opts.db)
-        #     rc = RC(stream_list != None)
-        #     rc.annotate("Load stream pack (from DB):")
-        #     if rc.bad():
-        #         return RC_ERR("Failed to load stream pack")
-        #
-        # else:
-        #     # load streams from file
-        #     stream_list = self.streams_db.load_yaml_file(opts.file[0])
-        #     rc = RC(stream_list != None)
-        #     rc.annotate("Load stream pack (from file):")
-        #     if stream_list == None:
-        #         return RC_ERR("Failed to load stream pack")
-        #
-        #
-        # return self.cmd_start(opts.ports, stream_list, opts.mult, opts.force, opts.duration)
+
+
+        return RC_OK()
+
+
+
+    @timing
+    def cmd_validate_line (self, line):
+        '''validates port(s) stream configuration\n'''
+
+        parser = parsing_opts.gen_parser(self,
+                                         "validate",
+                                         self.cmd_validate_line.__doc__,
+                                         parsing_opts.PORT_LIST_WITH_ALL)
+
+        opts = parser.parse_args(line.split())
+        if opts is None:
+            return RC_ERR("bad command line paramters")
+
+        rc = self.cmd_validate(opts.ports)
+        return rc
+
 
     def cmd_exit_line (self, line):
         print format_text("Exiting\n", 'bold')
@@ -1280,6 +1147,7 @@ class CTRexStatelessClient(object):
 
         return True
 
+
     #################################
     # ------ private methods ------ #
     @staticmethod
@@ -1294,17 +1162,18 @@ class CTRexStatelessClient(object):
     def _filter_namespace_args(namespace, ok_values):
         return {k: v for k, v in namespace.__dict__.items() if k in ok_values}
 
+
     #################################
     # ------ private classes ------ #
     class CCommLink(object):
         """describes the connectivity of the stateless client method"""
-        def __init__(self, server="localhost", port=5050, virtual=False):
+        def __init__(self, server="localhost", port=5050, virtual=False, prn_func = None):
             super(CTRexStatelessClient.CCommLink, self).__init__()
             self.virtual = virtual
             self.server = server
             self.port = port
             self.verbose = False
-            self.rpc_link = JsonRpcClient(self.server, self.port)
+            self.rpc_link = JsonRpcClient(self.server, self.port, prn_func)
 
         @property
         def is_connected(self):
@@ -1313,6 +1182,12 @@ class CTRexStatelessClient(object):
             else:
                 return True
 
+        def get_server (self):
+            return self.server
+
+        def get_port (self):
+            return self.port
+
         def set_verbose(self, mode):
             self.verbose = mode
             return self.rpc_link.set_verbose(mode)
@@ -1354,4 +1229,3 @@ class CTRexStatelessClient(object):
 
 if __name__ == "__main__":
     pass
-
diff --git a/scripts/automation/trex_control_plane/client_utils/jsonrpc_client.py b/scripts/automation/trex_control_plane/client_utils/jsonrpc_client.py
index dd208da4..bdae7bd9 100755
--- a/scripts/automation/trex_control_plane/client_utils/jsonrpc_client.py
+++ b/scripts/automation/trex_control_plane/client_utils/jsonrpc_client.py
@@ -7,8 +7,7 @@ import general_utils
 import re
 from time import sleep
 from collections import namedtuple
-
-CmdResponse = namedtuple('CmdResponse', ['success', 'data'])
+from common.trex_types import *
 
 class bcolors:
     BLUE = '\033[94m'
@@ -33,21 +32,17 @@ class BatchMessage(object):
 
     def invoke(self, block = False):
         if not self.rpc_client.connected:
-            return False, "Not connected to server"
+            return RC_ERR("Not connected to server")
 
         msg = json.dumps(self.batch_list)
 
-        rc, resp_list = self.rpc_client.send_raw_msg(msg, block = False)
-        if len(self.batch_list) == 1:
-            return CmdResponse(True, [CmdResponse(rc, resp_list)])
-        else:
-            return CmdResponse(rc, resp_list)
+        return self.rpc_client.send_raw_msg(msg)
 
 
 # JSON RPC v2.0 client
 class JsonRpcClient(object):
 
-    def __init__ (self, default_server, default_port):
+    def __init__ (self, default_server, default_port, prn_func = None):
         self.verbose = False
         self.connected = False
 
@@ -56,6 +51,8 @@ class JsonRpcClient(object):
         self.server = default_server
         self.id_gen = general_utils.random_id_gen()
 
+        self.prn_func = prn_func
+
     def get_connection_details (self):
         rc = {}
         rc['server'] = self.server
@@ -112,7 +109,7 @@ class JsonRpcClient(object):
 
     def invoke_rpc_method (self, method_name, params = {}):
         if not self.connected:
-            return False, "Not connected to server"
+            return RC_ERR("Not connected to server")
 
         id, msg = self.create_jsonrpc_v2(method_name, params)
 
@@ -130,11 +127,10 @@ class JsonRpcClient(object):
                 self.socket.send(msg)
                 break
             except zmq.Again:
-                sleep(0.1)
                 tries += 1
                 if tries > 10:
                     self.disconnect()
-                    return CmdResponse(False, "Failed to send message to server")
+                    return RC_ERR("*** [RPC] - Failed to send message to server")
 
 
         tries = 0
@@ -143,11 +139,10 @@ class JsonRpcClient(object):
                 response = self.socket.recv()
                 break
             except zmq.Again:
-                sleep(0.1)
                 tries += 1
                 if tries > 10:
                     self.disconnect()
-                    return CmdResponse(False, "Failed to get server response")
+                    return RC_ERR("*** [RPC] - Failed to get server response")
 
 
         self.verbose_msg("Server Response:\n\n" + self.pretty_json(response) + "\n")
@@ -158,36 +153,35 @@ class JsonRpcClient(object):
         response_json = json.loads(response)
 
         if isinstance(response_json, list):
-            rc_list = []
+            rc_batch = RC()
 
             for single_response in response_json:
-                rc, msg = self.process_single_response(single_response)
-                rc_list.append( CmdResponse(rc, msg) )
+                rc = self.process_single_response(single_response)
+                rc_batch.add(rc)
 
-            return CmdResponse(True, rc_list)
+            return rc_batch
 
         else:
-            rc, msg = self.process_single_response(response_json)
-            return CmdResponse(rc, msg)
+            return self.process_single_response(response_json)
 
 
     def process_single_response (self, response_json):
 
         if (response_json.get("jsonrpc") != "2.0"):
-            return False, "Malformed Response ({0})".format(str(response_json))
+            return RC_ERR("Malformed Response ({0})".format(str(response_json)))
 
         # error reported by server
         if ("error" in response_json):
             if "specific_err" in response_json["error"]:
-                return False, response_json["error"]["specific_err"]
+                return RC_ERR(response_json["error"]["specific_err"])
             else:
-                return False, response_json["error"]["message"]
+                return RC_ERR(response_json["error"]["message"])
 
         # if no error there should be a result
         if ("result" not in response_json):
-            return False, "Malformed Response ({0})".format(str(response_json))
+            return RC_ERR("Malformed Response ({0})".format(str(response_json)))
 
-        return True, response_json["result"]
+        return RC_OK(response_json["result"])
 
 
   
@@ -199,11 +193,12 @@ class JsonRpcClient(object):
             self.socket.close(linger = 0)
             self.context.destroy(linger = 0)
             self.connected = False
-            return True, ""
+            return RC_OK()
         else:
-            return False, "Not connected to server"
+            return RC_ERR("Not connected to server")
 
-    def connect(self, server=None, port=None):
+
+    def connect(self, server = None, port = None, prn_func = None):
         if self.connected:
             self.disconnect()
 
@@ -215,20 +210,24 @@ class JsonRpcClient(object):
         #  Socket to talk to server
         self.transport = "tcp://{0}:{1}".format(self.server, self.port)
 
-        print "\nConnecting To RPC Server On {0}".format(self.transport)
+        msg = "\nConnecting To RPC Server On {0}".format(self.transport)
+        if self.prn_func:
+            self.prn_func(msg)
+        else:
+            print msg
 
         self.socket = self.context.socket(zmq.REQ)
         try:
             self.socket.connect(self.transport)
         except zmq.error.ZMQError as e:
-            return False, "ZMQ Error: Bad server or port name: " + str(e)
+            return RC_ERR("ZMQ Error: Bad server or port name: " + str(e))
 
-        self.socket.setsockopt(zmq.SNDTIMEO, 5)
-        self.socket.setsockopt(zmq.RCVTIMEO, 5)
+        self.socket.setsockopt(zmq.SNDTIMEO, 1000)
+        self.socket.setsockopt(zmq.RCVTIMEO, 1000)
 
         self.connected = True
 
-        return True, ""
+        return RC_OK()
 
 
     def reconnect(self):
@@ -236,7 +235,7 @@ class JsonRpcClient(object):
         return self.connect()
 
         if not self.connected:
-            return False, "Not connected to server"
+            return RC_ERR("Not connected to server")
 
         # reconnect
         return self.connect(self.server, self.port)
diff --git a/scripts/automation/trex_control_plane/client_utils/packet_builder.py b/scripts/automation/trex_control_plane/client_utils/packet_builder.py
index 3aeb6a34..d8070c74 100755
--- a/scripts/automation/trex_control_plane/client_utils/packet_builder.py
+++ b/scripts/automation/trex_control_plane/client_utils/packet_builder.py
@@ -301,6 +301,30 @@ class CTRexPktBuilder(object):
                 break
         return
 
+    def load_packet_from_pcap(self, pcap_path):
+        """
+        This method loads a pcap file into a parsed packet builder object.
+
+        :parameters:
+            pcap_path: str
+                a path to a pcap file, containing a SINGLE packet.
+
+        :raises:
+            + :exc:`IOError`, in case provided path doesn't exists.
+
+        """
+        with open(pcap_path, 'r') as f:
+            pcap = dpkt.pcap.Reader(f)
+            first_packet = True
+            for _, buf in pcap:
+                # this is an iterator, can't evaluate the number of files in advance
+                if first_packet:
+                    self.load_packet(dpkt.ethernet.Ethernet(buf))
+                else:
+                    raise ValueError("Provided pcap file contains more than single packet.")
+        # arrive here ONLY if pcap contained SINGLE packet
+        return
+
     def get_packet(self, get_ptr=False):
         """
         This method provides access to the built packet, as an instance or as a pointer to packet itself.
diff --git a/scripts/automation/trex_control_plane/client_utils/parsing_opts.py b/scripts/automation/trex_control_plane/client_utils/parsing_opts.py
index 6c348467..6f9b4c6d 100755
--- a/scripts/automation/trex_control_plane/client_utils/parsing_opts.py
+++ b/scripts/automation/trex_control_plane/client_utils/parsing_opts.py
@@ -10,22 +10,24 @@ ArgumentGroup = namedtuple('ArgumentGroup', ['type', 'args', 'options'])
 
 # list of available parsing options
 MULTIPLIER = 1
-PORT_LIST = 2
-ALL_PORTS = 3
-PORT_LIST_WITH_ALL = 4
-FILE_PATH = 5
-FILE_FROM_DB = 6
-SERVER_IP = 7
-STREAM_FROM_PATH_OR_FILE = 8
-DURATION = 9
-FORCE = 10
-
-TOTAL = 11
-
-GLOBAL_STATS = 12
-PORT_STATS = 13
-PORT_STATUS = 14
-STATS_MASK = 15
+MULTIPLIER_STRICT = 2
+PORT_LIST = 3
+ALL_PORTS = 4
+PORT_LIST_WITH_ALL = 5
+FILE_PATH = 6
+FILE_FROM_DB = 7
+SERVER_IP = 8
+STREAM_FROM_PATH_OR_FILE = 9
+DURATION = 10
+FORCE = 11
+DRY_RUN = 12
+XTERM = 13
+TOTAL = 14
+
+GLOBAL_STATS = 50
+PORT_STATS = 51
+PORT_STATUS = 52
+STATS_MASK = 53
 
 # list of ArgumentGroup types
 MUTEX = 1
@@ -60,10 +62,15 @@ match_multiplier_help = """Multiplier should be passed in the following format:
                           will provide a percentage of the line rate. examples
                           : '-m 10', '-m 10kbps', '-m 10mpps', '-m 23%%' """
 
-def match_multiplier(val):
-    '''match some val against multiplier  shortcut inputs '''
+def match_multiplier_common(val, strict_abs = True):
 
-    match = re.match("^(\d+(\.\d+)?)(bps|kbps|mbps|gbps|pps|kpps|mpps|%?)$", val)
+    # on strict absolute we do not allow +/-
+    if strict_abs:
+        match = re.match("^(\d+(\.\d+)?)(bps|kbps|mbps|gbps|pps|kpps|mpps|%?)$", val)
+        op = None
+    else:
+        match = re.match("^(\d+(\.\d+)?)(bps|kbps|mbps|gbps|pps|kpps|mpps|%?)([\+\-])?$", val)
+        op  = match.group(4)
 
     result = {}
 
@@ -71,44 +78,53 @@ def match_multiplier(val):
 
         value = float(match.group(1))
         unit = match.group(3)
+        
 
+        
         # raw type (factor)
         if not unit:
             result['type'] = 'raw'
-            result['max'] = value
+            result['value'] = value
 
         elif unit == 'bps':
-            result['type'] = 'max_bps'
-            result['max'] = value
+            result['type'] = 'bps'
+            result['value'] = value
 
         elif unit == 'kbps':
-            result['type'] = 'max_bps'
-            result['max'] = value * 1000
+            result['type'] = 'bps'
+            result['value'] = value * 1000
 
         elif unit == 'mbps':
-            result['type'] = 'max_bps'
-            result['max'] = value * 1000 * 1000
+            result['type'] = 'bps'
+            result['value'] = value * 1000 * 1000
 
         elif unit == 'gbps':
-            result['type'] = 'max_bps'
-            result['max'] = value * 1000 * 1000 * 1000
+            result['type'] = 'bps'
+            result['value'] = value * 1000 * 1000 * 1000
 
         elif unit == 'pps':
-            result['type'] = 'max_pps'
-            result['max'] = value
+            result['type'] = 'pps'
+            result['value'] = value
 
         elif unit == "kpps":
-            result['type'] = 'max_pps'
-            result['max'] = value * 1000
+            result['type'] = 'pps'
+            result['value'] = value * 1000
 
         elif unit == "mpps":
-            result['type'] = 'max_pps'
-            result['max'] = value * 1000 * 1000
+            result['type'] = 'pps'
+            result['value'] = value * 1000 * 1000
 
         elif unit == "%":
-            # will be translated by the port object
             result['type'] = 'percentage'
-            result['max']  = value
+            result['value']  = value
+
+
+        if op == "+":
+            result['op'] = "add"
+        elif op == "-":
+            result['op'] = "sub"
+        else:
+            result['op'] = "abs"
 
         return result
 
@@ -116,6 +132,13 @@ def match_multiplier(val):
         raise argparse.ArgumentTypeError(match_multiplier_help)
 
 
+def match_multiplier(val):
+    '''match some val against multiplier  shortcut inputs '''
+    return match_multiplier_common(val, strict_abs = False)
+
+def match_multiplier_strict(val):
+    '''match some val against multiplier  shortcut inputs '''
+    return match_multiplier_common(val, strict_abs = True)
 
 def is_valid_file(filename):
     if not os.path.isfile(filename):
@@ -127,9 +150,14 @@ def is_valid_file(filename):
 OPTIONS_DB = {MULTIPLIER: ArgumentPack(['-m', '--multiplier'],
                                  {'help': match_multiplier_help,
                                   'dest': "mult",
-                                  'default': {'type':'raw', 'max':1},
+                                  'default': {'type':'raw', 'value':1, 'op': 'abs'},
                                   'type': match_multiplier}),
 
+              MULTIPLIER_STRICT: ArgumentPack(['-m', '--multiplier'],
+                               {'help': match_multiplier_help,
+                                  'dest': "mult",
+                                  'default': {'type':'raw', 'value':1, 'op': 'abs'},
+                                  'type': match_multiplier_strict}),
 
               TOTAL: ArgumentPack(['-t', '--total'],
                                  {'help': "traffic will be divided between all ports specified",
@@ -177,6 +205,19 @@ OPTIONS_DB = {MULTIPLIER: ArgumentPack(['-m', '--multiplier'],
                                       {'metavar': 'SERVER',
                                        'help': "server IP"}),
 
+              DRY_RUN: ArgumentPack(['-n', '--dry'],
+                                    {'action': 'store_true',
+                                     'dest': 'dry',
+                                     'default': False,
+                                     'help': "Dry run - no traffic will be injected"}),
+
+
+              XTERM: ArgumentPack(['-x', '--xterm'],
+                                  {'action': 'store_true',
+                                   'dest': 'xterm',
+                                   'default': False,
+                                   'help': "Starts TUI in xterm window"}),
+
               GLOBAL_STATS: ArgumentPack(['-g'],
                                          {'action': 'store_true',
                                           'help': "Fetch only global statistics"}),
@@ -189,6 +230,7 @@ OPTIONS_DB = {MULTIPLIER: ArgumentPack(['-m', '--multiplier'],
                                         {'action': 'store_true',
                                          'help': "Fetch only port status data"}),
 
+
               # advanced options
               PORT_LIST_WITH_ALL: ArgumentGroup(MUTEX, [PORT_LIST,
                                                         ALL_PORTS],
diff --git a/scripts/automation/trex_control_plane/common/text_opts.py b/scripts/automation/trex_control_plane/common/text_opts.py
index 06c2c056..5a86149c 100755
--- a/scripts/automation/trex_control_plane/common/text_opts.py
+++ b/scripts/automation/trex_control_plane/common/text_opts.py
@@ -19,6 +19,50 @@ TEXT_CODES = {'bold': {'start': '\x1b[1m',
                             'end': '\x1b[24m'}}
 
 
+def format_num (size, suffix = ""):
+    for unit in ['','K','M','G','T','P']:
+        if abs(size) < 1000.0:
+            return "%3.2f %s%s" % (size, unit, suffix)
+        size /= 1000.0
+
+    return "NaN"
+
+def format_time (t_sec):
+    if t_sec < 0:
+        return "infinite"
+
+    if t_sec < 1:
+        # low numbers
+        for unit in ['ms', 'usec', 'ns']:
+            t_sec *= 1000.0
+            if t_sec >= 1.0:
+                return '{:,.2f} [{:}]'.format(t_sec, unit)
+
+        return "NaN"
+
+    else:
+        # seconds
+        if t_sec < 60.0:
+            return '{:,.2f} [{:}]'.format(t_sec, 'sec')
+
+        # minutes
+        t_sec /= 60.0
+        if t_sec < 60.0:
+            return '{:,.2f} [{:}]'.format(t_sec, 'minutes')
+
+        # hours
+        t_sec /= 60.0
+        if t_sec < 24.0:
+            return '{:,.2f} [{:}]'.format(t_sec, 'hours')
+
+        # days
+        t_sec /= 24.0
+        return '{:,.2f} [{:}]'.format(t_sec, 'days')
+
+
+def format_percentage (size):
+    return "%0.2f %%" % (size)
+
 def bold(text):
     return text_attribute(text, 'bold')
 
diff --git a/scripts/automation/trex_control_plane/common/trex_stats.py b/scripts/automation/trex_control_plane/common/trex_stats.py
index 1f9d59e3..9562f1f5 100755
--- a/scripts/automation/trex_control_plane/common/trex_stats.py
+++ b/scripts/automation/trex_control_plane/common/trex_stats.py
@@ -5,12 +5,15 @@ from common.text_opts import format_text
 from client.trex_async_client import CTRexAsyncStats
 import copy
 import datetime
+import time
 import re
 
 GLOBAL_STATS = 'g'
 PORT_STATS = 'p'
 PORT_STATUS = 'ps'
 ALL_STATS_OPTS = {GLOBAL_STATS, PORT_STATS, PORT_STATUS}
+COMPACT = {GLOBAL_STATS, PORT_STATS}
+
 ExportableStats = namedtuple('ExportableStats', ['raw_data', 'text_table'])
 
 
@@ -54,15 +57,24 @@ class CTRexStatsGenerator(object):
 
         return_stats_data = {}
         per_field_stats = OrderedDict([("owner", []),
-                                       ("active", []),
+                                       ("state", []),
+                                       ("--", []),
+                                       ("opackets", []),
+                                       ("obytes", []),
+                                       ("ipackets", []),
+                                       ("ibytes", []),
+                                       ("ierrors", []),
+                                       ("oerrors", []),
                                        ("tx-bytes", []),
                                        ("rx-bytes", []),
                                        ("tx-pkts", []),
                                        ("rx-pkts", []),
-                                       ("tx-errors", []),
-                                       ("rx-errors", []),
-                                       ("tx-BW", []),
-                                       ("rx-BW", [])
+                                       ("---", []),
+                                       ("Tx bps", []),
+                                       ("Rx bps", []),
+                                       ("----", []),
+                                       ("Tx pps", []),
+                                       ("Rx pps", [])
                                       ]
                                       )
 
@@ -76,6 +88,9 @@ class CTRexStatsGenerator(object):
 
         stats_table = text_tables.TRexTextTable()
         stats_table.set_cols_align(["l"] + ["r"]*len(relevant_ports))
+        stats_table.set_cols_width([10] + [20] * len(relevant_ports))
+        stats_table.set_cols_dtype(['t'] + ['t'] * len(relevant_ports))
+
         stats_table.add_rows([[k] + v
                               for k, v in per_field_stats.iteritems()],
                              header=False)
@@ -106,6 +121,8 @@ class CTRexStatsGenerator(object):
 
         stats_table = text_tables.TRexTextTable()
         stats_table.set_cols_align(["l"] + ["c"]*len(relevant_ports))
+        stats_table.set_cols_width([10] + [20] * len(relevant_ports))
+
         stats_table.add_rows([[k] + v
                               for k, v in per_field_status.iteritems()],
                              header=False)
@@ -118,7 +135,8 @@ class CTRexStatsGenerator(object):
         # fetch owned ports
         ports = [port_obj
                  for _, port_obj in self._ports_dict.iteritems()
-                 if port_obj.is_acquired() and port_obj.port_id in port_id_list]
+                 if port_obj.port_id in port_id_list]
+        
         # display only the first FOUR options, by design
         if len(ports) > 4:
             print format_text("[WARNING]: ", 'magenta', 'bold'), format_text("displaying up to 4 ports", 'magenta')
@@ -139,7 +157,7 @@ class CTRexStats(object):
     def __init__(self):
         self.reference_stats = None
         self.latest_stats = {}
-        self.last_update_ts = datetime.datetime.now()
+        self.last_update_ts = time.time()
 
 
     def __getitem__(self, item):
@@ -176,6 +194,9 @@ class CTRexStats(object):
 
     @staticmethod
     def format_num(size, suffix = ""):
+        if type(size) == str:
+            return "N/A"
+
         for unit in ['','K','M','G','T','P']:
             if abs(size) < 1000.0:
                 return "%3.2f %s%s" % (size, unit, suffix)
@@ -188,16 +209,22 @@ class CTRexStats(object):
 
     def update(self, snapshot):
         # update
-        self.last_update_ts = datetime.datetime.now()
-
         self.latest_stats = snapshot
 
-        if self.reference_stats == None:
+        diff_time = time.time() - self.last_update_ts
+
+        # 3 seconds is too much - this is the new reference
+        if (self.reference_stats == None) or (diff_time > 3):
             self.reference_stats = self.latest_stats
 
+        self.last_update_ts = time.time()
+
     def clear_stats(self):
         self.reference_stats = self.latest_stats
 
+    def invalidate (self):
+        self.latest_stats = {}
+
     def get(self, field, format=False, suffix=""):
         if not field in self.latest_stats:
             return "N/A"
@@ -209,6 +236,7 @@ class CTRexStats(object):
     def get_rel(self, field, format=False, suffix=""):
         if not field in self.latest_stats:
             return "N/A"
+
         if not format:
             return (self.latest_stats[field] - self.reference_stats[field])
         else:
@@ -216,7 +244,6 @@ class CTRexStats(object):
 
 
 class CGlobalStats(CTRexStats):
-    pass
 
     def __init__(self, connection_info, server_version, ports_dict_ref):
         super(CGlobalStats, self).__init__()
@@ -242,7 +269,6 @@ class CGlobalStats(CTRexStats):
                             )
 
 class CPortStats(CTRexStats):
-    pass
 
     def __init__(self, port_obj):
         super(CPortStats, self).__init__()
@@ -250,15 +276,26 @@ class CPortStats(CTRexStats):
 
     def generate_stats(self):
         return {"owner": self._port_obj.user,
-                "active": "YES" if self._port_obj.is_active() else "NO",
+                "state": self._port_obj.get_port_state_name(),
+                "--": "",
+                "opackets" : self.get_rel("opackets"),
+                "obytes"   : self.get_rel("obytes"),
+                "ipackets" : self.get_rel("ipackets"),
+                "ibytes"   : self.get_rel("ibytes"),
+                "ierrors"  : self.get_rel("ierrors"),
+                "oerrors"  : self.get_rel("oerrors"),
+
                 "tx-bytes": self.get_rel("obytes", format = True, suffix = "B"),
                 "rx-bytes": self.get_rel("ibytes", format = True, suffix = "B"),
                 "tx-pkts": self.get_rel("opackets", format = True, suffix = "pkts"),
                 "rx-pkts": self.get_rel("ipackets", format = True, suffix = "pkts"),
-                "tx-errors": self.get_rel("oerrors", format = True),
-                "rx-errors": self.get_rel("ierrors", format = True),
-                "tx-BW": self.get("m_total_tx_bps", format = True, suffix = "bps"),
-                "rx-BW": self.get("m_total_rx_bps", format = True, suffix = "bps")
+
+                "---": "",
+                "Tx bps": self.get("m_total_tx_bps", format = True, suffix = "bps"),
+                "Rx bps": self.get("m_total_rx_bps", format = True, suffix = "bps"),
+                "----": "",
+                "Tx pps": self.get("m_total_tx_pps", format = True, suffix = "pps"),
+                "Rx pps": self.get("m_total_rx_pps", format = True, suffix = "pps"),
                 }
 
 
diff --git a/scripts/automation/trex_control_plane/common/trex_streams.py b/scripts/automation/trex_control_plane/common/trex_streams.py
index bb4c72ca..86eee1f4 100755
--- a/scripts/automation/trex_control_plane/common/trex_streams.py
+++ b/scripts/automation/trex_control_plane/common/trex_streams.py
@@ -10,18 +10,31 @@ import copy
 import os
 
 StreamPack = namedtuple('StreamPack', ['stream_id', 'stream'])
+LoadedStreamList = namedtuple('LoadedStreamList', ['loaded', 'compiled'])
 
 class CStreamList(object):
 
     def __init__(self):
-        self.streams_list = {}
+        self.streams_list = OrderedDict()
         self.yaml_loader = CTRexYAMLLoader(os.path.join(os.path.dirname(os.path.realpath(__file__)), 
                                                         "rpc_defaults.yaml"))
 
+    def generate_numbered_name (self, name):
+        prefix = name.rstrip('01234567890')
+        suffix = name[len(prefix):]
+        if suffix == "":
+            n = "_1"
+        else:
+            n = int(suffix) + 1
+        return prefix + str(n)
+
     def append_stream(self, name, stream_obj):
         assert isinstance(stream_obj, CStream)
-        if name in self.streams_list:
-            raise NameError("A stream with this name already exists on this list.")
+
+        # if name exists simply add numbered suffix to it
+        while name in self.streams_list:
+            name = self.generate_numbered_name(name)
+
         self.streams_list[name]=stream_obj
         return name
 
@@ -70,6 +83,7 @@ class CStreamList(object):
         stream_ids = {}
         for idx, stream_name in enumerate(self.streams_list):
             stream_ids[stream_name] = idx
+
         # next, iterate over the streams and transform them from working with names to ids.
         # with that build a new dict with old stream_name as the key, and StreamPack as the stored value 
         compiled_streams = {}
@@ -241,5 +255,61 @@ class CStream(object):
             raise RuntimeError("CStream object isn't loaded with data. Use 'load_data' method.")
 
 
-if __name__ == "__main__":
-    pass
+
+# describes a stream DB
+class CStreamsDB(object):
+
+    def __init__(self):
+        self.stream_packs = {}
+
+    def load_yaml_file(self, filename):
+
+        stream_pack_name = filename
+        if stream_pack_name in self.get_loaded_streams_names():
+            self.remove_stream_packs(stream_pack_name)
+
+        stream_list = CStreamList()
+        loaded_obj = stream_list.load_yaml(filename)
+
+        try:
+            compiled_streams = stream_list.compile_streams()
+            rc = self.load_streams(stream_pack_name,
+                                   LoadedStreamList(loaded_obj,
+                                                    [StreamPack(v.stream_id, v.stream.dump())
+                                                     for k, v in compiled_streams.items()]))
+
+        except Exception as e:
+            return None
+
+        return self.get_stream_pack(stream_pack_name)
+
+    def load_streams(self, name, LoadedStreamList_obj):
+        if name in self.stream_packs:
+            return False
+        else:
+            self.stream_packs[name] = LoadedStreamList_obj
+            return True
+
+    def remove_stream_packs(self, *names):
+        removed_streams = []
+        for name in names:
+            removed = self.stream_packs.pop(name)
+            if removed:
+                removed_streams.append(name)
+        return removed_streams
+
+    def clear(self):
+        self.stream_packs.clear()
+
+    def get_loaded_streams_names(self):
+        return self.stream_packs.keys()
+
+    def stream_pack_exists (self, name):
+        return name in self.get_loaded_streams_names()
+
+    def get_stream_pack(self, name):
+        if not self.stream_pack_exists(name):
+            return None
+        else:
+            return self.stream_packs.get(name)
+
diff --git a/scripts/automation/trex_control_plane/common/trex_types.py b/scripts/automation/trex_control_plane/common/trex_types.py
new file mode 100644
index 00000000..7c3f04c5
--- /dev/null
+++ b/scripts/automation/trex_control_plane/common/trex_types.py
@@ -0,0 +1,68 @@
+
+from collections import namedtuple
+from common.text_opts import *
+
+RpcCmdData = namedtuple('RpcCmdData', ['method', 'params'])
+
+class RpcResponseStatus(namedtuple('RpcResponseStatus', ['success', 'id', 'msg'])):
+        __slots__ = ()
+        def __str__(self):
+            return "{id:^3} - {msg} ({stat})".format(id=self.id,
+                                                  msg=self.msg,
+                                                  stat="success" if self.success else "fail")
+
+# simple class to represent complex return value
+class RC():
+
+    def __init__ (self, rc = None, data = None):
+        self.rc_list = []
+
+        if (rc != None) and (data != None):
+            tuple_rc = namedtuple('RC', ['rc', 'data'])
+            self.rc_list.append(tuple_rc(rc, data))
+
+    def add (self, rc):
+        self.rc_list += rc.rc_list
+
+    def good (self):
+        return all([x.rc for x in self.rc_list])
+
+    def bad (self):
+        return not self.good()
+
+    def data (self):
+        d = [x.data if x.rc else "" for x in self.rc_list]
+        return (d if len(d) > 1 else d[0])
+
+    def err (self):
+        e = [x.data if not x.rc else "" for x in self.rc_list]
+        return (e if len(e) > 1 else e[0])
+
+    def annotate (self, desc = None, show_status = True):
+        if desc:
+            print format_text('\n{:<60}'.format(desc), 'bold'),
+        else:
+            print ""
+
+        if self.bad():
+            # print all the errors
+            print ""
+            for x in self.rc_list:
+                if not x.rc:
+                    print format_text("\n{0}".format(x.data), 'bold')
+
+            print ""
+            if show_status:
+                print format_text("[FAILED]\n", 'red', 'bold')
+
+
+        else:
+            if show_status:
+                print format_text("[SUCCESS]\n", 'green', 'bold')
+
+
+def RC_OK(data = ""):
+    return RC(True, data)
+def RC_ERR (err):
+    return RC(False, err)
+
diff --git a/scripts/automation/trex_control_plane/console/old_console.py b/scripts/automation/trex_control_plane/console/old_console.py
deleted file mode 100644
index 9d61a3a6..00000000
--- a/scripts/automation/trex_control_plane/console/old_console.py
+++ /dev/null
@@ -1,958 +0,0 @@
-
-# main console object
-class TRexConsole1(cmd.Cmd):
-    """Trex Console"""
-
-    def __init__(self, stateless_client, verbose):
-        cmd.Cmd.__init__(self)
-
-        self.stateless_client = stateless_client
-
-        self.do_connect("")
-
-        self.intro  = "\n-=TRex Console v{ver}=-\n".format(ver=__version__)
-        self.intro += "\nType 'help' or '?' for supported actions\n"
-
-        self.verbose = False
-        self._silent = True
-
-        self.postcmd(False, "")
-
-        self.user_streams = {}
-        self.streams_db = CStreamsDB()
-
-
-    # a cool hack - i stole this function and added space
-    def completenames(self, text, *ignored):
-        dotext = 'do_'+text
-        return [a[3:]+' ' for a in self.get_names() if a.startswith(dotext)]
-
-
-    # set verbose on / off
-    def do_verbose(self, line):
-        '''Shows or set verbose mode\n'''
-        if line == "":
-            print "\nverbose is " + ("on\n" if self.verbose else "off\n")
-
-        elif line == "on":
-            self.verbose = True
-            self.stateless_client.set_verbose(True)
-            print green("\nverbose set to on\n")
-
-        elif line == "off":
-            self.verbose = False
-            self.stateless_client.set_verbose(False)
-            print green("\nverbose set to off\n")
-
-        else:
-            print magenta("\nplease specify 'on' or 'off'\n")
-
-    # query the server for registered commands
-    def do_query_server(self, line):
-        '''query the RPC server for supported remote commands\n'''
-
-        res_ok, msg = self.stateless_client.get_supported_cmds()
-        if not res_ok:
-            print format_text("[FAILED]\n", 'red', 'bold')
-            return
-        print "\nRPC server supports the following commands:\n"
-        for func in msg:
-            if func:
-                print func
-        print ''
-        print format_text("[SUCCESS]\n", 'green', 'bold')
-        return
-
-    def do_ping(self, line):
-        '''Pings the RPC server\n'''
-
-        print "\n-> Pinging RPC server"
-
-        res_ok, msg = self.stateless_client.ping()
-        if res_ok:
-            print format_text("[SUCCESS]\n", 'green', 'bold')
-        else:
-            print "\n*** " + msg + "\n"
-            return
-
-    def do_force_acquire(self, line):
-        '''Acquires ports by force\n'''
-
-        self.do_acquire(line, True)
-
-    def complete_force_acquire(self, text, line, begidx, endidx):
-        return self.port_auto_complete(text, line, begidx, endidx, acquired=False)
-
-    def extract_port_ids_from_line(self, line):
-        return {int(x) for x in line.split()}
-
-    def extract_port_ids_from_list(self, port_list):
-        return {int(x) for x in port_list}
-
-    def parse_ports_from_line (self, line):
-        port_list = set()
-        if line:
-            for port_id in line.split(' '):
-                if (not port_id.isdigit()) or (int(port_id) < 0) or (int(port_id) >= self.stateless_client.get_port_count()):
-                    print "Please provide a list of ports separated by spaces between 0 and {0}".format(self.stateless_client.get_port_count() - 1)
-                    return None
-
-                port_list.add(int(port_id))
-
-            port_list = list(port_list)
-
-        else:
-            port_list = [i for i in xrange(0, self.stateless_client.get_port_count())]
-
-        return port_list
-
-
-    def do_acquire(self, line, force=False):
-        '''Acquire ports\n'''
-
-        # make sure that the user wants to acquire all
-        args = line.split()
-        if len(args) < 1:
-            print magenta("Please provide a list of ports separated by spaces, or specify 'all' to acquire all available ports")
-            return
-
-        if args[0] == "all":
-            ask = ConfirmMenu('Are you sure you want to acquire all ports ? ')
-            rc = ask.show()
-            if rc == False:
-                print yellow("[ABORTED]\n")
-                return
-            else:
-                port_list = self.stateless_client.get_port_ids()
-        else:
-            port_list = self.extract_port_ids_from_line(line)
-
-        # rc, resp_list = self.stateless_client.take_ownership(port_list, force)
-        try:
-            res_ok, log = self.stateless_client.acquire(port_list, force)
-            self.prompt_response(log)
-            if not res_ok:
-                print format_text("[FAILED]\n", 'red', 'bold')
-                return
-            print format_text("[SUCCESS]\n", 'green', 'bold')
-        except ValueError as e:
-            print magenta(str(e))
-            print format_text("[FAILED]\n", 'red', 'bold')
-
-
-    def port_auto_complete(self, text, line, begidx, endidx, acquired=True, active=False):
-        if acquired:
-            if not active:
-                ret_list = [x
-                            for x in map(str, self.stateless_client.get_acquired_ports())
-                            if x.startswith(text)]
-            else:
-                ret_list = [x
-                            for x in map(str, self.stateless_client.get_active_ports())
-                            if x.startswith(text)]
-        else:
-            ret_list = [x
-                        for x in map(str, self.stateless_client.get_port_ids())
-                        if x.startswith(text)]
-        ret_list.append("all")
-        return ret_list
-
-
-    def complete_acquire(self, text, line, begidx, endidx):
-        return self.port_auto_complete(text, line, begidx, endidx, acquired=False)
-
-    def do_release (self, line):
-        '''Release ports\n'''
-
-        # if line:
-        #     port_list = self.parse_ports_from_line(line)
-        # else:
-        #     port_list = self.stateless_client.get_owned_ports()
-        args = line.split()
-        if len(args) < 1:
-            print "Please provide a list of ports separated by spaces, or specify 'all' to acquire all available ports"
-        if args[0] == "all":
-            ask = ConfirmMenu('Are you sure you want to release all acquired ports? ')
-            rc = ask.show()
-            if rc == False:
-                print yellow("[ABORTED]\n")
-                return
-            else:
-                port_list = self.stateless_client.get_acquired_ports()
-        else:
-            port_list = self.extract_port_ids_from_line(line)
-
-        try:
-            res_ok, log = self.stateless_client.release(port_list)
-            self.prompt_response(log)
-            if not res_ok:
-                print format_text("[FAILED]\n", 'red', 'bold')
-                return
-            print format_text("[SUCCESS]\n", 'green', 'bold')
-        except ValueError as e:
-            print magenta(str(e))
-            print format_text("[FAILED]\n", 'red', 'bold')
-            return
-
-    def complete_release(self, text, line, begidx, endidx):
-        return self.port_auto_complete(text, line, begidx, endidx)
-
-    def do_connect (self, line):
-        '''Connects to the server\n'''
-
-        if line == "":
-            res_ok, msg = self.stateless_client.connect()
-        else:
-            sp = line.split()
-            if (len(sp) != 2):
-                print "\n[usage] connect [server] [port] or without parameters\n"
-                return
-
-            res_ok, msg = self.stateless_client.connect(sp[0], sp[1])
-
-        if res_ok:
-            print format_text("[SUCCESS]\n", 'green', 'bold')
-        else:
-            print "\n*** " + msg + "\n"
-            print format_text("[FAILED]\n", 'red', 'bold')
-            return
-
-        self.supported_rpc = self.stateless_client.get_supported_cmds().data
-
-    # def do_rpc (self, line):
-    #     '''Launches a RPC on the server\n'''
-    #
-    #     if line == "":
-    #         print "\nUsage: [method name] [param dict as string]\n"
-    #         print "Example: rpc test_add {'x': 12, 'y': 17}\n"
-    #         return
-    #
-    #     sp = line.split(' ', 1)
-    #     method = sp[0]
-    #
-    #     params = None
-    #     bad_parse = False
-    #     if len(sp) > 1:
-    #
-    #         try:
-    #             params = ast.literal_eval(sp[1])
-    #             if not isinstance(params, dict):
-    #                 bad_parse = True
-    #
-    #         except ValueError as e1:
-    #             bad_parse = True
-    #         except SyntaxError as e2:
-    #             bad_parse = True
-    #
-    #     if bad_parse:
-    #         print "\nValue should be a valid dict: '{0}'".format(sp[1])
-    #         print "\nUsage: [method name] [param dict as string]\n"
-    #         print "Example: rpc test_add {'x': 12, 'y': 17}\n"
-    #         return
-    #
-    #     res_ok, msg = self.stateless_client.transmit(method, params)
-    #     if res_ok:
-    #         print "\nServer Response:\n\n" + pretty_json(json.dumps(msg)) + "\n"
-    #     else:
-    #         print "\n*** " + msg + "\n"
-    #         #print "Please try 'reconnect' to reconnect to server"
-    #
-    #
-    # def complete_rpc (self, text, line, begidx, endidx):
-    #     return [x
-    #             for x in self.supported_rpc
-    #             if x.startswith(text)]
-
-    def do_status (self, line):
-        '''Shows a graphical console\n'''
-
-        if not self.stateless_client.is_connected():
-            print "Not connected to server\n"
-            return
-
-        self.do_verbose('off')
-        trex_status.show_trex_status(self.stateless_client)
-
-    def do_quit(self, line):
-        '''Exit the client\n'''
-        return True
-
-    def do_disconnect (self, line):
-        '''Disconnect from the server\n'''
-        if not self.stateless_client.is_connected():
-            print "Not connected to server\n"
-            return
-
-        res_ok, msg = self.stateless_client.disconnect()
-        if res_ok:
-            print format_text("[SUCCESS]\n", 'green', 'bold')
-        else:
-            print msg + "\n"
-
-    def do_whoami (self, line):
-        '''Prints console user name\n'''
-        print "\n" + self.stateless_client.user + "\n"
-
-    def postcmd(self, stop, line):
-        if self.stateless_client.is_connected():
-            self.prompt = "TRex > "
-        else:
-            self.supported_rpc = None
-            self.prompt = "TRex (offline) > "
-
-        return stop
-
-    def default(self, line):
-        print "'{0}' is an unrecognized command. type 'help' or '?' for a list\n".format(line)
-
-    # def do_help (self, line):
-    #     '''Shows This Help Screen\n'''
-    #     if line:
-    #         try:
-    #             func = getattr(self, 'help_' + line)
-    #         except AttributeError:
-    #             try:
-    #                 doc = getattr(self, 'do_' + line).__doc__
-    #                 if doc:
-    #                     self.stdout.write("%s\n"%str(doc))
-    #                     return
-    #             except AttributeError:
-    #                 pass
-    #             self.stdout.write("%s\n"%str(self.nohelp % (line,)))
-    #             return
-    #         func()
-    #         return
-    #
-    #     print "\nSupported Console Commands:"
-    #     print "----------------------------\n"
-    #
-    #     cmds =  [x[3:] for x in self.get_names() if x.startswith("do_")]
-    #     for cmd in cmds:
-    #         if cmd == "EOF":
-    #             continue
-    #
-    #         try:
-    #             doc = getattr(self, 'do_' + cmd).__doc__
-    #             if doc:
-    #                 help = str(doc)
-    #             else:
-    #                 help = "*** Undocumented Function ***\n"
-    #         except AttributeError:
-    #             help = "*** Undocumented Function ***\n"
-    #
-    #         print "{:<30} {:<30}".format(cmd + " - ", help)
-
-    def do_stream_db_add(self, line):
-        '''Loads a YAML stream list serialization into user console \n'''
-        args = line.split()
-        if len(args) >= 2:
-            name = args[0]
-            yaml_path = args[1]
-            try:
-                multiplier = args[2]
-            except IndexError:
-                multiplier = 1
-            stream_list = CStreamList()
-            loaded_obj = stream_list.load_yaml(yaml_path, multiplier)
-            # print self.stateless_client.pretty_json(json.dumps(loaded_obj))
-            try:
-                compiled_streams = stream_list.compile_streams()
-                res_ok = self.streams_db.load_streams(name, LoadedStreamList(loaded_obj,
-                                                                             [StreamPack(v.stream_id, v.stream.dump())
-                                                                              for k, v in compiled_streams.items()]))
-                if res_ok:
-                    print green("Stream pack '{0}' loaded and added successfully\n".format(name))
-                else:
-                    print magenta("Picked name already exist. Please pick another name.\n")
-            except Exception as e:
-                print "adding new stream failed due to the following error:\n", str(e)
-                print format_text("[FAILED]\n", 'red', 'bold')
-
-            return
-        else:
-            print magenta("please provide load name and YAML path, separated by space.\n"
-                          "Optionally, you may provide a third argument to specify multiplier.\n")
-
-    @staticmethod
-    def tree_autocomplete(text):
-        dir = os.path.dirname(text)
-        if dir:
-            path = dir
-        else:
-            path = "."
-        start_string = os.path.basename(text)
-        return [x
-                for x in os.listdir(path)
-                if x.startswith(start_string)]
-
-
-    def complete_stream_db_add(self, text, line, begidx, endidx):
-        arg_num = len(line.split()) - 1
-        if arg_num == 2:
-            return TRexConsole.tree_autocomplete(line.split()[-1])
-        else:
-            return [text]
-
-    def do_stream_db_show(self, line):
-        '''Shows the loaded stream list named [name] \n'''
-        args = line.split()
-        if args:
-            list_name = args[0]
-            try:
-                stream = self.streams_db.get_stream_pack(list_name)#user_streams[list_name]
-                if len(args) >= 2 and args[1] == "full":
-                    print pretty_json(json.dumps(stream.compiled))
-                else:
-                    print pretty_json(json.dumps(stream.loaded))
-            except KeyError as e:
-                print "Unknown stream list name provided"
-        else:
-            print "Available stream packs:\n{0}".format(', '.join(sorted(self.streams_db.get_loaded_streams_names())))
-
-    def complete_stream_db_show(self, text, line, begidx, endidx):
-        return [x
-                for x in self.streams_db.get_loaded_streams_names()
-                if x.startswith(text)]
-
-    def do_stream_db_remove(self, line):
-        '''Removes a single loaded stream packs from loaded stream pack repository\n'''
-        args = line.split()
-        if args:
-            removed_streams = self.streams_db.remove_stream_packs(*args)
-            if removed_streams:
-                print green("The following stream packs were removed:")
-                print bold(", ".join(sorted(removed_streams)))
-                print format_text("[SUCCESS]\n", 'green', 'bold')
-            else:
-                print red("No streams were removed. Make sure to provide valid stream pack names.")
-        else:
-            print magenta("Please provide stream pack name(s), separated with spaces.")
-
-    def do_stream_db_clear(self, line):
-        '''Clears all loaded stream packs from loaded stream pack repository\n'''
-        self.streams_db.clear()
-        print format_text("[SUCCESS]\n", 'green', 'bold')
-
-
-    def complete_stream_db_remove(self, text, line, begidx, endidx):
-        return [x
-                for x in self.streams_db.get_loaded_streams_names()
-                if x.startswith(text)]
-
-
-    def do_attach(self, line):
-        '''Assign loaded stream pack into specified ports on TRex\n'''
-        args = line.split()
-        if len(args) >= 2:
-            stream_pack_name = args[0]
-            stream_list = self.streams_db.get_stream_pack(stream_pack_name) #user_streams[args[0]]
-            if not stream_list:
-                print "Provided stream list name '{0}' doesn't exists.".format(stream_pack_name)
-                print format_text("[FAILED]\n", 'red', 'bold')
-                return
-            if args[1] == "all":
-                ask = ConfirmMenu('Are you sure you want to release all acquired ports? ')
-                rc = ask.show()
-                if rc == False:
-                    print yellow("[ABORTED]\n")
-                    return
-                else:
-                    port_list = self.stateless_client.get_acquired_ports()
-            else:
-                port_list = self.extract_port_ids_from_line(' '.join(args[1:]))
-            owned = set(self.stateless_client.get_acquired_ports())
-            try:
-                if set(port_list).issubset(owned):
-                    res_ok, log = self.stateless_client.add_stream_pack(stream_list.compiled, port_id=port_list)
-                    # res_ok, msg = self.stateless_client.add_stream(port_list, stream_list.compiled)
-                    self.prompt_response(log)
-                    if not res_ok:
-                        print format_text("[FAILED]\n", 'red', 'bold')
-                        return
-                    print format_text("[SUCCESS]\n", 'green', 'bold')
-                    return
-                else:
-                    print "Not all desired ports are acquired.\n" \
-                          "Acquired ports are: {acq}\n" \
-                          "Requested ports:    {req}\n" \
-                          "Missing ports:      {miss}".format(acq=list(owned),
-                                                              req=port_list,
-                                                              miss=list(set(port_list).difference(owned)))
-                    print format_text("[FAILED]\n", 'red', 'bold')
-            except ValueError as e:
-                print magenta(str(e))
-                print format_text("[FAILED]\n", 'red', 'bold')
-        else:
-            print magenta("Please provide list name and ports to attach to, "
-                          "or specify 'all' to attach all owned ports.\n")
-
-    def complete_attach(self, text, line, begidx, endidx):
-        arg_num = len(line.split()) - 1
-        if arg_num == 1:
-            # return optional streams packs
-            if line.endswith(" "):
-                return self.port_auto_complete(text, line, begidx, endidx)
-            return [x
-                    for x in self.streams_db.get_loaded_streams_names()
-                    if x.startswith(text)]
-        elif arg_num >= 2:
-            # return optional ports to attach to
-            return self.port_auto_complete(text, line, begidx, endidx)
-        else:
-            return [text]
-
-    def prompt_response(self, response_obj):
-        resp_list = response_obj if isinstance(response_obj, list) else [response_obj]
-        def format_return_status(return_status):
-            if return_status:
-                return green("OK")
-            else:
-                return red("FAIL")
-
-        for response in resp_list:
-            response_str = "{id:^3} - {msg} ({stat})".format(id=response.id,
-                                                             msg=response.msg,
-                                                             stat=format_return_status(response.success))
-            print response_str
-        return
-
-    def do_remove_all_streams(self, line):
-        '''Acquire ports\n'''
-
-        # make sure that the user wants to acquire all
-        args = line.split()
-        if len(args) < 1:
-            print magenta("Please provide a list of ports separated by spaces, "
-                          "or specify 'all' to remove from all acquired ports")
-            return
-        if args[0] == "all":
-            ask = ConfirmMenu('Are you sure you want to remove all stream packs from all acquired ports? ')
-            rc = ask.show()
-            if rc == False:
-                print yellow("[ABORTED]\n")
-                return
-            else:
-                port_list = self.stateless_client.get_acquired_ports()
-        else:
-            port_list = self.extract_port_ids_from_line(line)
-
-        # rc, resp_list = self.stateless_client.take_ownership(port_list, force)
-        try:
-            res_ok, log = self.stateless_client.remove_all_streams(port_list)
-            self.prompt_response(log)
-            if not res_ok:
-                print format_text("[FAILED]\n", 'red', 'bold')
-                return
-            print format_text("[SUCCESS]\n", 'green', 'bold')
-        except ValueError as e:
-            print magenta(str(e))
-            print format_text("[FAILED]\n", 'red', 'bold')
-
-    def complete_remove_all_streams(self, text, line, begidx, endidx):
-        return self.port_auto_complete(text, line, begidx, endidx)
-
-    def do_start(self, line):
-        '''Start selected traffic in specified ports on TRex\n'''
-        # make sure that the user wants to acquire all
-        parser = parsing_opts.gen_parser("start", self.do_start.__doc__,
-                                         parsing_opts.PORT_LIST_WITH_ALL,
-                                         parsing_opts.FORCE,
-                                         parsing_opts.STREAM_FROM_PATH_OR_FILE,
-                                         parsing_opts.DURATION,
-                                         parsing_opts.MULTIPLIER)
-        opts = parser.parse_args(line.split())
-        if opts is None:
-            # avoid further processing in this command
-            return
-        # print opts
-        port_list = self.extract_port_list(opts)
-        # print port_list
-        if opts.force:
-            # stop all active ports, if any
-            res_ok = self.stop_traffic(set(self.stateless_client.get_active_ports()).intersection(port_list))
-            if not res_ok:
-                print yellow("[ABORTED]\n")
-                return
-        # remove all traffic from ports
-        res_ok = self.remove_all_streams(port_list)
-        if not res_ok:
-            print yellow("[ABORTED]\n")
-            return
-        # decide which traffic to use
-        stream_pack_name = None
-        if opts.db:
-            # use pre-loaded traffic
-            print format_text('{:<30}'.format("Load stream pack (from DB):"), 'bold'),
-            if opts.db not in self.streams_db.get_loaded_streams_names():
-                print format_text("[FAILED]\n", 'red', 'bold')
-                print yellow("[ABORTED]\n")
-                return
-            else:
-                stream_pack_name = opts.db
-        else:
-            # try loading a YAML file
-            print format_text('{:<30}'.format("Load stream pack (from file):"), 'bold'),
-            stream_list = CStreamList()
-            loaded_obj = stream_list.load_yaml(opts.file[0])
-            # print self.stateless_client.pretty_json(json.dumps(loaded_obj))
-            try:
-                compiled_streams = stream_list.compile_streams()
-                res_ok = self.streams_db.load_streams(opts.file[1],
-                                                      LoadedStreamList(loaded_obj,
-                                                                       [StreamPack(v.stream_id, v.stream.dump())
-                                                                        for k, v in compiled_streams.items()]))
-                if not res_ok:
-                    print format_text("[FAILED]\n", 'red', 'bold')
-                    print yellow("[ABORTED]\n")
-                    return
-                print format_text("[SUCCESS]\n", 'green', 'bold')
-                stream_pack_name = opts.file[1]
-            except Exception as e:
-                print format_text("[FAILED]\n", 'red', 'bold')
-                print yellow("[ABORTED]\n")
-        res_ok = self.attach_to_port(stream_pack_name, port_list)
-        if not res_ok:
-            print yellow("[ABORTED]\n")
-            return
-        # finally, start the traffic
-        res_ok = self.start_traffic(opts.mult, port_list)
-        if not res_ok:
-            print yellow("[ABORTED]\n")
-            return
-        return
-
-    def help_start(self):
-        self.do_start("-h")
-
-    def do_stop(self, line):
-        '''Stop active traffic in specified ports on TRex\n'''
-        parser = parsing_opts.gen_parser("stop", self.do_stop.__doc__,
-                                         parsing_opts.PORT_LIST_WITH_ALL)
-        opts = parser.parse_args(line.split())
-        if opts is None:
-            # avoid further processing in this command
-            return
-        port_list = self.extract_port_list(opts)
-        res_ok = self.stop_traffic(port_list)
-        return
-
-    def do_pause(self, line):
-        '''Pause active traffic in specified ports on TRex\n'''
-        parser = parsing_opts.gen_parser("stop", self.do_stop.__doc__,
-                                         parsing_opts.PORT_LIST_WITH_ALL)
-        opts = parser.parse_args(line.split())
-        if opts is None:
-            # avoid further processing in this command
-            return
-        port_list = self.extract_port_list(opts)
-        res_ok = self.stop_traffic(port_list)
-        return
-
-
-    def help_stop(self):
-        self.do_stop("-h")
-
-
-    def do_debug(self, line):
-        '''Enter DEBUG mode of the console to invoke smaller building blocks with server'''
-        i = DebugTRexConsole(self)
-        i.prompt = self.prompt[:-3] + ':' + blue('debug') + ' > '
-        i.cmdloop()
-
-    # aliasing
-    do_exit = do_EOF = do_q = do_quit
-
-    # ----- utility methods ----- #
-
-    def start_traffic(self, multiplier, port_list):#, silent=True):
-        print format_text('{:<30}'.format("Start traffic:"), 'bold'),
-        try:
-            res_ok, log = self.stateless_client.start_traffic(multiplier, port_id=port_list)
-            if not self._silent:
-                print ''
-                self.prompt_response(log)
-            if not res_ok:
-                print format_text("[FAILED]\n", 'red', 'bold')
-                return False
-            print format_text("[SUCCESS]\n", 'green', 'bold')
-            return True
-        except ValueError as e:
-            print ''
-            print magenta(str(e))
-            print format_text("[FAILED]\n", 'red', 'bold')
-            return False
-
-    def attach_to_port(self, stream_pack_name, port_list):
-        print format_text('{:<30}'.format("Attaching traffic to ports:"), 'bold'),
-        stream_list = self.streams_db.get_stream_pack(stream_pack_name) #user_streams[args[0]]
-        if not stream_list:
-            print "Provided stream list name '{0}' doesn't exists.".format(stream_pack_name)
-            print format_text("[FAILED]\n", 'red', 'bold')
-            return
-        try:
-            res_ok, log = self.stateless_client.add_stream_pack(stream_list.compiled, port_id=port_list)
-            if not self._silent:
-                print ''
-                self.prompt_response(log)
-            if not res_ok:
-                print format_text("[FAILED]\n", 'red', 'bold')
-                return False
-            print format_text("[SUCCESS]\n", 'green', 'bold')
-            return True
-        except ValueError as e:
-            print ''
-            print magenta(str(e))
-            print format_text("[FAILED]\n", 'red', 'bold')
-            return False
-
-    def stop_traffic(self, port_list):
-        print format_text('{:<30}'.format("Stop traffic:"), 'bold'),
-        try:
-            res_ok, log = self.stateless_client.stop_traffic(port_id=port_list)
-            if not self._silent:
-                print ''
-                self.prompt_response(log)
-            if not res_ok:
-                print format_text("[FAILED]\n", 'red', 'bold')
-                return
-            print format_text("[SUCCESS]\n", 'green', 'bold')
-            return True
-        except ValueError as e:
-            print ''
-            print magenta(str(e))
-            print format_text("[FAILED]\n", 'red', 'bold')
-
-    def remove_all_streams(self, port_list):
-        '''Remove all streams from given port_list'''
-        print format_text('{:<30}'.format("Remove all streams:"), 'bold'),
-        try:
-            res_ok, log = self.stateless_client.remove_all_streams(port_id=port_list)
-            if not self._silent:
-                print ''
-                self.prompt_response(log)
-            if not res_ok:
-                print format_text("[FAILED]\n", 'red', 'bold')
-                return
-            print format_text("[SUCCESS]\n", 'green', 'bold')
-            return True
-        except ValueError as e:
-            print ''
-            print magenta(str(e))
-            print format_text("[FAILED]\n", 'red', 'bold')
-
-
-
-
-
-    def extract_port_list(self, opts):
-        if opts.all_ports or "all" in opts.ports:
-            # handling all ports
-            port_list = self.stateless_client.get_acquired_ports()
-        else:
-            port_list = self.extract_port_ids_from_list(opts.ports)
-        return port_list
-
-    def decode_multiplier(self, opts_mult):
-        pass
-
-
-class DebugTRexConsole(cmd.Cmd):
-
-    def __init__(self, trex_main_console):
-        cmd.Cmd.__init__(self)
-        self.trex_console = trex_main_console
-        self.stateless_client = self.trex_console.stateless_client
-        self.streams_db = self.trex_console.streams_db
-        self.register_main_console_methods()
-        self.do_silent("on")
-        pass
-
-    # ----- super methods overriding ----- #
-    def completenames(self, text, *ignored):
-        dotext = 'do_'+text
-        return [a[3:]+' ' for a in self.get_names() if a.startswith(dotext)]
-
-    def get_names(self):
-        result = cmd.Cmd.get_names(self)
-        result += self.trex_console.get_names()
-        return list(set(result))
-
-    def register_main_console_methods(self):
-        main_names = set(self.trex_console.get_names()).difference(set(dir(self.__class__)))
-        for name in main_names:
-            for prefix in 'do_', 'help_', 'complete_':
-                if name.startswith(prefix):
-                    self.__dict__[name] = getattr(self.trex_console, name)
-
-            # if (name[:3] == 'do_') or (name[:5] == 'help_') or (name[:9] == 'complete_'):
-            #     chosen.append(name)
-            #     self.__dict__[name] = getattr(self.trex_console, name)
-            #     # setattr(self, name, classmethod(getattr(self.trex_console, name)))
-
-        # print chosen
-        # self.get_names()
-
-        # return result
-
-
-    # ----- DEBUGGING methods ----- #
-    # set silent on / off
-    def do_silent(self, line):
-        '''Shows or set silent mode\n'''
-        if line == "":
-            print "\nsilent mode is " + ("on\n" if self.trex_console._silent else "off\n")
-
-        elif line == "on":
-            self.verbose = True
-            self.stateless_client.set_verbose(True)
-            print green("\nsilent set to on\n")
-
-        elif line == "off":
-            self.verbose = False
-            self.stateless_client.set_verbose(False)
-            print green("\nsilent set to off\n")
-
-        else:
-            print magenta("\nplease specify 'on' or 'off'\n")
-
-    def do_quit(self, line):
-        '''Exit the debug client back to main console\n'''
-        self.do_silent("off")
-        return True
-
-    def do_start_traffic(self, line):
-        '''Start pre-submitted traffic in specified ports on TRex\n'''
-        # make sure that the user wants to acquire all
-        parser = parsing_opts.gen_parser("start_traffic", self.do_start_traffic.__doc__,
-                                         parsing_opts.PORT_LIST_WITH_ALL, parsing_opts.MULTIPLIER)
-        opts = parser.parse_args(line.split())
-        # print opts
-        # return
-        if opts is None:
-            # avoid further processing in this command
-            return
-        try:
-            port_list = self.trex_console.extract_port_list(opts)
-            return self.trex_console.start_traffic(opts.mult, port_list)
-        except Exception as e:
-            print e
-            return
-
-    def do_stop_traffic(self, line):
-        '''Stop active traffic in specified ports on TRex\n'''
-        parser = parsing_opts.gen_parser("stop_traffic", self.do_stop_traffic.__doc__,
-                                         parsing_opts.PORT_LIST_WITH_ALL)
-        opts = parser.parse_args(line.split())
-        # print opts
-        # return
-        if opts is None:
-            # avoid further processing in this command
-            return
-        try:
-            port_list = self.trex_console.extract_port_list(opts)
-            return self.trex_console.stop_traffic(port_list)
-        except Exception as e:
-            print e
-            return
-
-
-    def complete_stop_traffic(self, text, line, begidx, endidx):
-        return self.port_auto_complete(text, line, begidx, endidx, active=True)
-
-        # return
-        # # return
-        # # if not opts.port_list:
-        # #     print magenta("Please provide a list of ports separated by spaces, "
-        # #                   "or specify 'all' to start traffic on all acquired ports")
-        # #     return
-        #
-
-
-        return
-        args = line.split()
-        if len(args) < 1:
-            print magenta("Please provide a list of ports separated by spaces, "
-                          "or specify 'all' to start traffic on all acquired ports")
-            return
-        if args[0] == "all":
-            ask = ConfirmMenu('Are you sure you want to start traffic at all acquired ports? ')
-            rc = ask.show()
-            if rc == False:
-                print yellow("[ABORTED]\n")
-                return
-            else:
-                port_list = self.stateless_client.get_acquired_ports()
-        else:
-            port_list = self.extract_port_ids_from_line(line)
-
-        try:
-            res_ok, log = self.stateless_client.start_traffic(1.0, port_id=port_list)
-            self.prompt_response(log)
-            if not res_ok:
-                print format_text("[FAILED]\n", 'red', 'bold')
-                return
-            print format_text("[SUCCESS]\n", 'green', 'bold')
-        except ValueError as e:
-            print magenta(str(e))
-            print format_text("[FAILED]\n", 'red', 'bold')
-
-    def complete_start_traffic(self, text, line, begidx, endidx):
-        # return self.port_auto_complete(text, line, begidx, endidx)
-        return [text]
-
-    def help_start_traffic(self):
-        self.do_start_traffic("-h")
-
-    def help_stop_traffic(self):
-        self.do_stop_traffic("-h")
-
-    # def do_help(self):
-
-    def do_rpc (self, line):
-        '''Launches a RPC on the server\n'''
-
-        if line == "":
-            print "\nUsage: [method name] [param dict as string]\n"
-            print "Example: rpc test_add {'x': 12, 'y': 17}\n"
-            return
-
-        sp = line.split(' ', 1)
-        method = sp[0]
-
-        params = None
-        bad_parse = False
-        if len(sp) > 1:
-
-            try:
-                params = ast.literal_eval(sp[1])
-                if not isinstance(params, dict):
-                    bad_parse = True
-
-            except ValueError as e1:
-                bad_parse = True
-            except SyntaxError as e2:
-                bad_parse = True
-
-        if bad_parse:
-            print "\nValue should be a valid dict: '{0}'".format(sp[1])
-            print "\nUsage: [method name] [param dict as string]\n"
-            print "Example: rpc test_add {'x': 12, 'y': 17}\n"
-            return
-
-        res_ok, msg = self.stateless_client.transmit(method, params)
-        if res_ok:
-            print "\nServer Response:\n\n" + pretty_json(json.dumps(msg)) + "\n"
-        else:
-            print "\n*** " + msg + "\n"
-            #print "Please try 'reconnect' to reconnect to server"
-
-
-    def complete_rpc (self, text, line, begidx, endidx):
-        return [x
-                for x in self.trex_console.supported_rpc
-                if x.startswith(text)]
-
-    # aliasing
-    do_exit = do_EOF = do_q = do_quit
-
-#
diff --git a/scripts/automation/trex_control_plane/console/trex_console.py b/scripts/automation/trex_control_plane/console/trex_console.py
index 9236ce98..a3ea6693 100755
--- a/scripts/automation/trex_control_plane/console/trex_console.py
+++ b/scripts/automation/trex_control_plane/console/trex_console.py
@@ -17,7 +17,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-
+import subprocess
 import cmd
 import json
 import ast
@@ -34,8 +34,8 @@ from client.trex_stateless_client import CTRexStatelessClient
 from common.text_opts import *
 from client_utils.general_utils import user_input, get_current_user
 from client_utils import parsing_opts
-import trex_status
-
+import trex_tui
+from functools import wraps
 
 
 __version__ = "1.1"
@@ -114,13 +114,13 @@ class TRexGeneralCmd(cmd.Cmd):
 class TRexConsole(TRexGeneralCmd):
     """Trex Console"""
 
-    def __init__(self, stateless_client, acquire_all_ports=True, verbose=False):
+    def __init__(self, stateless_client, verbose=False):
         self.stateless_client = stateless_client
         TRexGeneralCmd.__init__(self)
 
+        self.tui = trex_tui.TrexTUI(stateless_client)
 
         self.verbose = verbose
-        self.acquire_all_ports = acquire_all_ports
 
         self.intro  = "\n-=TRex Console v{ver}=-\n".format(ver=__version__)
         self.intro += "\nType 'help' or '?' for supported actions\n"
@@ -130,9 +130,49 @@ class TRexConsole(TRexGeneralCmd):
 
     ################### internal section ########################
 
+    def verify_connected(f):
+        @wraps(f)
+        def wrap(*args):
+            inst = args[0]
+            func_name = f.__name__
+            if func_name.startswith("do_"):
+                func_name = func_name[3:]
+
+            if not inst.stateless_client.is_connected():
+                print format_text("\n'{0}' cannot be executed on offline mode\n".format(func_name), 'bold')
+                return
+
+            ret = f(*args)
+            return ret
+
+        return wrap
+
+    # TODO: remove this ugly duplication
+    def verify_connected_and_rw (f):
+        @wraps(f)
+        def wrap(*args):
+            inst = args[0]
+            func_name = f.__name__
+            if func_name.startswith("do_"):
+                func_name = func_name[3:]
+
+            if not inst.stateless_client.is_connected():
+                print format_text("\n'{0}' cannot be executed on offline mode\n".format(func_name), 'bold')
+                return
+
+            if inst.stateless_client.is_read_only():
+                print format_text("\n'{0}' cannot be executed on read only mode\n".format(func_name), 'bold')
+                return
+
+            rc = f(*args)
+            return rc
+
+        return wrap
+
+
     def get_console_identifier(self):
         return "{context}_{server}".format(context=self.__class__.__name__,
-                                           server=self.stateless_client.get_system_info()['hostname'])
+                                           server=self.stateless_client.get_server_ip())
     
     def register_main_console_methods(self):
         main_names = set(self.trex_console.get_names()).difference(set(dir(self.__class__)))
@@ -142,11 +182,18 @@ class TRexConsole(TRexGeneralCmd):
                     self.__dict__[name] = getattr(self.trex_console, name)
 
     def postcmd(self, stop, line):
-        if self.stateless_client.is_connected():
-            self.prompt = "TRex > "
-        else:
-            self.supported_rpc = None
+
+        if not self.stateless_client.is_connected():
             self.prompt = "TRex (offline) > "
+            self.supported_rpc = None
+            return stop
+
+        if self.stateless_client.is_read_only():
+            self.prompt = "TRex (read only) > "
+            return stop
+
+
+        self.prompt = "TRex > "
 
         return stop
 
@@ -208,9 +255,9 @@ class TRexConsole(TRexGeneralCmd):
 
 
     ####################### shell commands #######################
+    @verify_connected
     def do_ping (self, line):
         '''Ping the server\n'''
-
         rc = self.stateless_client.cmd_ping()
         if rc.bad():
             return
@@ -224,12 +271,12 @@ class TRexConsole(TRexGeneralCmd):
 
         elif line == "on":
             self.verbose = True
-            self.stateless_client.set_verbose(True)
+            self.stateless_client.set_verbose(self.stateless_client.VERBOSE_HIGH)
             print format_text("\nverbose set to on\n", 'green', 'bold')
 
         elif line == "off":
             self.verbose = False
-            self.stateless_client.set_verbose(False)
+            self.stateless_client.set_verbose(self.stateless_client.VERBOSE_REGULAR)
             print format_text("\nverbose set to off\n", 'green', 'bold')
 
         else:
@@ -273,17 +320,13 @@ class TRexConsole(TRexGeneralCmd):
     def do_connect (self, line):
         '''Connects to the server\n'''
 
-        rc = self.stateless_client.cmd_connect()
-        if rc.bad():
-            return
+        self.stateless_client.cmd_connect_line(line)
 
 
     def do_disconnect (self, line):
         '''Disconnect from the server\n'''
 
-        rc = self.stateless_client.cmd_disconnect()
-        if rc.bad():
-            return
+        self.stateless_client.cmd_disconnect()
 
  
     ############### start
@@ -300,56 +343,79 @@ class TRexConsole(TRexGeneralCmd):
         if (l > 2) and (s[l - 2] in file_flags):
             return TRexConsole.tree_autocomplete(s[l - 1])
 
+    @verify_connected_and_rw
     def do_start(self, line):
         '''Start selected traffic in specified port(s) on TRex\n'''
 
         self.stateless_client.cmd_start_line(line)
 
+        
+
 
     def help_start(self):
         self.do_start("-h")
 
     ############# stop
+    @verify_connected_and_rw
     def do_stop(self, line):
         '''stops port(s) transmitting traffic\n'''
+
         self.stateless_client.cmd_stop_line(line)
 
     def help_stop(self):
         self.do_stop("-h")
 
     ############# update
+    @verify_connected_and_rw
     def do_update(self, line):
         '''update speed of port(s)currently transmitting traffic\n'''
+
         self.stateless_client.cmd_update_line(line)
 
     def help_update (self):
         self.do_update("-h")
 
     ############# pause
+    @verify_connected_and_rw
     def do_pause(self, line):
         '''pause port(s) transmitting traffic\n'''
+
         self.stateless_client.cmd_pause_line(line)
 
     ############# resume
+    @verify_connected_and_rw
     def do_resume(self, line):
         '''resume port(s) transmitting traffic\n'''
+
         self.stateless_client.cmd_resume_line(line)
 
    
 
     ########## reset
+    @verify_connected_and_rw
     def do_reset (self, line):
         '''force stop all ports\n'''
-        self.stateless_client.cmd_reset()
+        self.stateless_client.cmd_reset_line(line)
 
+
+    ######### validate
+    @verify_connected
+    def do_validate (self, line):
+        '''validates port(s) stream configuration\n'''
+
+        self.stateless_client.cmd_validate_line(line)
+
+
+    @verify_connected
     def do_stats(self, line):
         '''Fetch statistics from TRex server by port\n'''
         self.stateless_client.cmd_stats_line(line)
-        pass
+
 
     def help_stats(self):
         self.do_stats("-h")
 
+    @verify_connected
     def do_clear(self, line):
         '''Clear cached local statistics\n'''
         self.stateless_client.cmd_clear_line(line)
@@ -386,16 +452,43 @@ class TRexConsole(TRexGeneralCmd):
             self.stateless_client.clear_events()
             print format_text("\n\nEvent log was cleared\n\n")
 
+
     # tui
+    @verify_connected
     def do_tui (self, line):
         '''Shows a graphical console\n'''
 
-        if not self.stateless_client.is_connected():
-            print format_text("\nNot connected to server\n", 'bold')
+        parser = parsing_opts.gen_parser(self,
+                                         "tui",
+                                         self.do_tui.__doc__,
+                                         parsing_opts.XTERM)
+
+        opts = parser.parse_args(line.split())
+        if opts is None:
+            return
+
+        if opts.xterm:
+            exe = ''
+            if os.path.isfile('/usr/bin/wmctrl'):
+                exe += '/usr/bin/wmctrl -r trex_tui -b add,above;'
+
+            exe += './trex-console -t -q -s {0} -p {1}'.format(self.stateless_client.get_server_ip(), self.stateless_client.get_server_port())
+
+            cmd = ['xterm', '-geometry', '105x40', '-title', 'trex_tui', '-e', exe]
+            subprocess.Popen(cmd)
+
             return
 
-        self.do_verbose('off')
-        trex_status.show_trex_status(self.stateless_client)
+        save_verbose = self.stateless_client.get_verbose()
+
+        self.stateless_client.set_verbose(self.stateless_client.VERBOSE_QUIET)
+        self.tui.show()
+        self.stateless_client.set_verbose(save_verbose)
+
+
+    def help_tui (self):
+        do_tui("-h")
+
 
     # quit function
     def do_quit(self, line):
@@ -487,6 +580,15 @@ def setParserOptions():
                         help = "Run the console in a batch mode with file",
                         default = None)
 
+    parser.add_argument("-t", "--tui", dest="tui",
+                        action="store_true", help="Starts with TUI mode",
+                        default = False)
+
+
+    parser.add_argument("-q", "--quiet", dest="quiet",
+                        action="store_true", help="Starts with all outputs suppressed",
+                        default = False)
+
     return parser
 
 
@@ -495,11 +597,24 @@ def main():
     options = parser.parse_args()
 
     # Stateless client connection
-    stateless_client = CTRexStatelessClient(options.user, options.server, options.port, options.pub)
-    rc = stateless_client.cmd_connect()
+    stateless_client = CTRexStatelessClient(options.user, options.server, options.port, options.pub, options.quiet)
+
+    if not options.quiet:
+        print "\nlogged as {0}".format(format_text(options.user, 'bold'))
+
+    # TUI or no acquire will give us READ ONLY mode
+    if options.tui or not options.acquire:
+        rc = stateless_client.connect("RO")
+    else:
+        rc = stateless_client.connect("RW")
+
+    # unable to connect - bye
     if rc.bad():
+        rc.annotate()
         return
 
+
+    # a script mode
     if options.batch:
         cont = stateless_client.run_script_file(options.batch[0])
         if not cont:
@@ -507,11 +622,17 @@ def main():
         
     # console
     try:
-        console = TRexConsole(stateless_client, options.acquire, options.verbose)
-        console.cmdloop()
+        console = TRexConsole(stateless_client, options.verbose)
+        if options.tui:
+            console.do_tui("")
+        else:
+            console.cmdloop()
+
     except KeyboardInterrupt as e:
         print "\n\n*** Caught Ctrl + C... Exiting...\n\n"
-        return
+        
+    finally:
+        stateless_client.disconnect()
 
 if __name__ == '__main__':
     main()
diff --git a/scripts/automation/trex_control_plane/console/trex_tui.py b/scripts/automation/trex_control_plane/console/trex_tui.py
new file mode 100644
index 00000000..febe62f4
--- /dev/null
+++ b/scripts/automation/trex_control_plane/console/trex_tui.py
@@ -0,0 +1,469 @@
+import termios
+import sys
+import os
+import time
+from common.text_opts import *
+from common import trex_stats
+from client_utils import text_tables
+from collections import OrderedDict
+import datetime
+
+class SimpleBar(object):
+    def __init__ (self, desc, pattern):
+        self.desc = desc
+        self.pattern = pattern
+        self.pattern_len = len(pattern)
+        self.index = 0
+
+    def show (self):
+        if self.desc:
+            print format_text("{0} {1}".format(self.desc, self.pattern[self.index]), 'bold')
+        else:
+            print format_text("{0}".format(self.pattern[self.index]), 'bold')
+
+        self.index = (self.index + 1) % self.pattern_len
+
+
+# base type of a panel
+class TrexTUIPanel(object):
+    def __init__ (self, mng, name):
+
+        self.mng = mng
+        self.name = name
+        self.stateless_client = mng.stateless_client
+
+    def show (self):
+        raise NotImplementedError("must implement this")
+
+    def get_key_actions (self):
+        raise NotImplementedError("must implement this")
+
+    def get_name (self):
+        return self.name
+
+
+# dashboard panel
+class TrexTUIDashBoard(TrexTUIPanel):
+    def __init__ (self, mng):
+        super(TrexTUIDashBoard, self).__init__(mng, "dashboard")
+
+        self.key_actions = OrderedDict()
+
+        self.key_actions['c'] = {'action': self.action_clear,  'legend': 'clear', 'show': True}
+        self.key_actions['p'] = {'action': self.action_pause,  'legend': 'pause', 'show': True}
+        self.key_actions['r'] = {'action': self.action_resume, 'legend': 'resume', 'show': True}
+        self.key_actions['+'] = {'action': self.action_raise,  'legend': 'up 5%', 'show': True}
+        self.key_actions['-'] = {'action': self.action_lower,  'legend': 'low 5%', 'show': True}
+
+        self.ports = self.stateless_client.get_all_ports()
+
+
+    def show (self):
+        stats = self.stateless_client.cmd_stats(self.ports, trex_stats.COMPACT)
+        # print stats to screen
+        for stat_type, stat_data in stats.iteritems():
+            text_tables.print_table_with_header(stat_data.text_table, stat_type)
+
+
+    def get_key_actions (self):
+        allowed = {}
+
+        allowed['c'] = self.key_actions['c']
+
+        # thats it for read only
+        if self.stateless_client.is_read_only():
+            return allowed
+
+        if len(self.stateless_client.get_transmitting_ports()) > 0:
+            allowed['p'] = self.key_actions['p']
+            allowed['+'] = self.key_actions['+']
+            allowed['-'] = self.key_actions['-']
+
+
+        if len(self.stateless_client.get_paused_ports()) > 0:
+            allowed['r'] = self.key_actions['r']
+
+        return allowed
+
+
+    ######### actions
+    def action_pause (self):
+        rc = self.stateless_client.pause_traffic(self.mng.ports)
+
+        ports_succeeded = []
+        for rc_single, port_id in zip(rc.rc_list, self.mng.ports):
+            if rc_single.rc:
+                ports_succeeded.append(port_id)
+
+        if len(ports_succeeded) > 0:
+            return "paused traffic on port(s): {0}".format(ports_succeeded)
+        else:
+            return ""
+
+
+    def action_resume (self):
+        rc = self.stateless_client.resume_traffic(self.mng.ports)
+
+        ports_succeeded = []
+        for rc_single, port_id in zip(rc.rc_list, self.mng.ports):
+            if rc_single.rc:
+                ports_succeeded.append(port_id)
+
+        if len(ports_succeeded) > 0:
+            return "resumed traffic on port(s): {0}".format(ports_succeeded)
+        else:
+            return ""
+
+
+    def action_raise (self):
+        mul = {'type': 'percentage', 'value': 5, 'op': 'add'}
+        rc = self.stateless_client.update_traffic(mul, self.mng.ports)
+
+        ports_succeeded = []
+        for rc_single, port_id in zip(rc.rc_list, self.mng.ports):
+            if rc_single.rc:
+                ports_succeeded.append(port_id)
+
+        if len(ports_succeeded) > 0:
+            return "raised B/W by %5 on port(s): {0}".format(ports_succeeded)
+        else:
+            return ""
+
+    def action_lower (self):
+        mul = {'type': 'percentage', 'value': 5, 'op': 'sub'}
+        rc = self.stateless_client.update_traffic(mul, self.mng.ports)
+
+        ports_succeeded = []
+        for rc_single, port_id in zip(rc.rc_list, self.mng.ports):
+            if rc_single.rc:
+                ports_succeeded.append(port_id)
+
+        if len(ports_succeeded) > 0:
+            return "lowered B/W by %5 on port(s): {0}".format(ports_succeeded)
+        else:
+            return ""
+
+
+    def action_clear (self):
+        self.stateless_client.cmd_clear(self.mng.ports)
+        return "cleared all stats"
+
+
+# port panel
+class TrexTUIPort(TrexTUIPanel):
+    def __init__ (self, mng, port_id):
+        super(TrexTUIPort, self).__init__(mng, "port {0}".format(port_id))
+
+        self.port_id = port_id
+        self.port = self.mng.stateless_client.get_port(port_id)
+
+        self.key_actions = OrderedDict()
+
+        self.key_actions['c'] = {'action': self.action_clear,  'legend': 'clear', 'show': True}
+        self.key_actions['p'] = {'action': self.action_pause, 'legend': 'pause', 'show': True}
+        self.key_actions['r'] = {'action': self.action_resume, 'legend': 'resume', 'show': True}
+        self.key_actions['+'] = {'action': self.action_raise, 'legend': 'up 5%', 'show': True}
+        self.key_actions['-'] = {'action': self.action_lower, 'legend': 'low 5%', 'show': True}
+
+
+    def show (self):
+        stats = self.stateless_client.cmd_stats([self.port_id], trex_stats.COMPACT)
+        # print stats to screen
+        for stat_type, stat_data in stats.iteritems():
+            text_tables.print_table_with_header(stat_data.text_table, stat_type)
+
+    def get_key_actions (self):
+
+        allowed = {}
+
+        allowed['c'] = self.key_actions['c']
+
+        # thats it for read only
+        if self.stateless_client.is_read_only():
+            return allowed
+
+        if self.port.state == self.port.STATE_TX:
+            allowed['p'] = self.key_actions['p']
+            allowed['+'] = self.key_actions['+']
+            allowed['-'] = self.key_actions['-']
+
+        elif self.port.state == self.port.STATE_PAUSE:
+            allowed['r'] = self.key_actions['r']
+
+
+        return allowed
+
+    # actions
+    def action_pause (self):
+        rc = self.stateless_client.pause_traffic([self.port_id])
+        if rc.good():
+            return "port {0}: paused traffic".format(self.port_id)
+        else:
+            return ""
+
+    def action_resume (self):
+        rc = self.stateless_client.resume_traffic([self.port_id])
+        if rc.good():
+            return "port {0}: resumed traffic".format(self.port_id)
+        else:
+            return ""
+
+    def action_raise (self):
+        mul = {'type': 'percentage', 'value': 5, 'op': 'add'}
+        rc = self.stateless_client.update_traffic(mul, [self.port_id])
+
+        if rc.good():
+            return "port {0}: raised B/W by 5%".format(self.port_id)
+        else:
+            return ""
+
+    def action_lower (self):
+        mul = {'type': 'percentage', 'value': 5, 'op': 'sub'}
+        rc = self.stateless_client.update_traffic(mul, [self.port_id])
+
+        if rc.good():
+            return "port {0}: lowered B/W by 5%".format(self.port_id)
+        else:
+            return ""
+
+    def action_clear (self):
+        self.stateless_client.cmd_clear([self.port_id])
+        return "port {0}: cleared stats".format(self.port_id)
+
+# log
+class TrexTUILog():
+    def __init__ (self):
+        self.log = []
+
+    def add_event (self, msg):
+        self.log.append("[{0}] {1}".format(str(datetime.datetime.now().time()), msg))
+
+    def show (self, max_lines = 4):
+
+        cut = len(self.log) - max_lines
+        if cut < 0:
+            cut = 0
+
+        print format_text("\nLog:", 'bold', 'underline')
+
+        for msg in self.log[cut:]:
+            print msg
+
+
+# Panels manager (contains server panels)
+class TrexTUIPanelManager():
+    def __init__ (self, tui):
+        self.tui = tui
+        self.stateless_client = tui.stateless_client
+        self.ports = self.stateless_client.get_all_ports()
+        
+
+        self.panels = {}
+        self.panels['dashboard'] = TrexTUIDashBoard(self)
+
+        self.key_actions = OrderedDict()
+        self.key_actions['q'] = {'action': self.action_quit, 'legend': 'quit', 'show': True}
+        self.key_actions['g'] = {'action': self.action_show_dash, 'legend': 'dashboard', 'show': True}
+
+        for port_id in self.ports:
+            self.key_actions[str(port_id)] = {'action': self.action_show_port(port_id), 'legend': 'port {0}'.format(port_id), 'show': False}
+            self.panels['port {0}'.format(port_id)] = TrexTUIPort(self, port_id)
+
+        # start with dashboard
+        self.main_panel = self.panels['dashboard']
+
+        # log object
+        self.log = TrexTUILog()
+
+        self.generate_legend()
+
+        self.conn_bar = SimpleBar('status: ', ['|','/','-','\\'])
+        self.dis_bar =  SimpleBar('status: ', ['X', ' '])
+        self.show_log = False
+
+
+    def generate_legend (self):
+        self.legend = "\n{:<12}".format("browse:")
+
+        for k, v in self.key_actions.iteritems():
+            if v['show']:
+                x = "'{0}' - {1}, ".format(k, v['legend'])
+                self.legend += "{:}".format(x)
+
+        self.legend += "'0-{0}' - port display".format(len(self.ports) - 1)
+
+
+        self.legend += "\n{:<12}".format(self.main_panel.get_name() + ":")
+        for k, v in self.main_panel.get_key_actions().iteritems():
+            if v['show']:
+                x = "'{0}' - {1}, ".format(k, v['legend'])
+                self.legend += "{:}".format(x)
+
+
+    def print_connection_status (self):
+        if self.tui.get_state() == self.tui.STATE_ACTIVE:
+            self.conn_bar.show()
+        else:
+            self.dis_bar.show()
+
+    def print_legend (self):
+        print format_text(self.legend, 'bold')
+
+
+    # on window switch or turn on / off of the TUI we call this
+    def init (self, show_log = False):
+        self.show_log = show_log
+        self.generate_legend()
+
+    def show (self):
+        self.main_panel.show()
+        self.print_connection_status()
+        self.print_legend()
+
+        if self.show_log:
+            self.log.show()
+
+
+    def handle_key (self, ch):
+        # check for the manager registered actions
+        if ch in self.key_actions:
+            msg = self.key_actions[ch]['action']()
+
+        # check for main panel actions
+        elif ch in self.main_panel.get_key_actions():
+            msg = self.main_panel.get_key_actions()[ch]['action']()
+
+        else:
+            msg = ""
+
+        self.generate_legend()
+
+        if msg == None:
+            return False
+        else:
+            if msg:
+                self.log.add_event(msg)
+            return True
+            
+
+    # actions
+
+    def action_quit (self):
+        return None
+
+    def action_show_dash (self):
+        self.main_panel = self.panels['dashboard']
+        self.init(self.show_log)
+        return ""
+
+    def action_show_port (self, port_id):
+        def action_show_port_x ():
+            self.main_panel = self.panels['port {0}'.format(port_id)]
+            self.init()
+            return ""
+
+        return action_show_port_x
+
+
+
+# shows a textual top style window
+class TrexTUI():
+
+    STATE_ACTIVE     = 0
+    STATE_LOST_CONT  = 1
+    STATE_RECONNECT  = 2
+
+    def __init__ (self, stateless_client):
+        self.stateless_client = stateless_client
+
+        self.pm = TrexTUIPanelManager(self)
+
+
+
+    def handle_key_input (self):
+        # try to read a single key
+        ch = os.read(sys.stdin.fileno(), 1)
+        if ch != None and len(ch) > 0:
+            return (self.pm.handle_key(ch), True)
+
+        else:
+            return (True, False)
+            
+
+    def clear_screen (self):
+        #os.system('clear')
+        # maybe this is faster ?
+        sys.stderr.write("\x1b[2J\x1b[H")
+
+
+
+    def show (self, show_log = False):
+        # init termios
+        old_settings = termios.tcgetattr(sys.stdin)
+        new_settings = termios.tcgetattr(sys.stdin)
+        new_settings[3] = new_settings[3] & ~(termios.ECHO | termios.ICANON) # lflags
+        new_settings[6][termios.VMIN] = 0  # cc
+        new_settings[6][termios.VTIME] = 0 # cc
+        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, new_settings)
+
+        self.pm.init(show_log)
+
+        self.state = self.STATE_ACTIVE
+        self.draw_policer = 0
+
+        try:
+            while True:
+                # draw and handle user input
+                cont, force_draw = self.handle_key_input()
+                self.draw_screen(force_draw)
+                if not cont:
+                    break
+                time.sleep(0.1)
+
+                # regular state
+                if self.state == self.STATE_ACTIVE:
+                    # if no connectivity - move to lost connecitivty
+                    if not self.stateless_client.async_client.is_alive():
+                        self.stateless_client.cmd_invalidate(self.pm.ports)
+                        self.state = self.STATE_LOST_CONT
+
+
+                # lost connectivity
+                elif self.state == self.STATE_LOST_CONT:
+                    # got it back
+                    if self.stateless_client.async_client.is_alive():
+                        # move to state reconnect
+                        self.state = self.STATE_RECONNECT
+
+
+                # restored connectivity - try to reconnect
+                elif self.state == self.STATE_RECONNECT:
+
+                    rc = self.stateless_client.connect("RO")
+                    if rc.good():
+                        self.state = self.STATE_ACTIVE
+                    else:
+                        # maybe we lost it again
+                        self.state = self.STATE_LOST_CONT
+
+
+        finally:
+            # restore
+            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_settings)
+
+        print ""
+
+
+    # draw once
+    def draw_screen (self, force_draw = False):
+
+        if (self.draw_policer >= 5) or (force_draw):
+            self.clear_screen()
+            self.pm.show()
+            self.draw_policer = 0
+        else:
+            self.draw_policer += 1 
+
+    def get_state (self):
+        return self.state
+
diff --git a/scripts/automation/trex_control_plane/server/extended_daemon_runner.py b/scripts/automation/trex_control_plane/server/extended_daemon_runner.py
index 734fa22e..7bc25aac 100755
--- a/scripts/automation/trex_control_plane/server/extended_daemon_runner.py
+++ b/scripts/automation/trex_control_plane/server/extended_daemon_runner.py
@@ -19,7 +19,6 @@ def daemonize_parser(parser_obj, action_funcs, help_menu):
     parser_obj.usage = None

     parser_obj.add_argument("action", choices=action_funcs,

                             action="store", help=help_menu)

-    return

 

 

 class ExtendedDaemonRunner(runner.DaemonRunner):

@@ -76,7 +75,12 @@ class ExtendedDaemonRunner(runner.DaemonRunner):
         self.app = app

         self.daemon_context = daemon.DaemonContext()

         self.daemon_context.stdin = open(app.stdin_path, 'rt')

-        self.daemon_context.stdout = open(app.stdout_path, 'w+t')

+        try:

+            self.daemon_context.stdout = open(app.stdout_path, 'w+t')

+        except IOError as err:

+            # catch 'tty' error when launching server from remote location

+            app.stdout_path = "/dev/null"

+            self.daemon_context.stdout = open(app.stdout_path, 'w+t')

         self.daemon_context.stderr = open(app.stderr_path,

                                           'a+t', buffering=0)

 

diff --git a/scripts/automation/trex_control_plane/server/trex_daemon_server.py b/scripts/automation/trex_control_plane/server/trex_daemon_server.py
index ec07cb8a..9784d42a 100755
--- a/scripts/automation/trex_control_plane/server/trex_daemon_server.py
+++ b/scripts/automation/trex_control_plane/server/trex_daemon_server.py
@@ -57,15 +57,7 @@ def main ():
                 print "Launching user must have sudo privileges in order to run TRex daemon.\nTerminating daemon process."
             exit(-1)
 
-    try:
-        daemon_runner = ExtendedDaemonRunner(trex_app, trex_parser)
-    except IOError as err:
-        # catch 'tty' error when launching server from remote location
-        if err.errno == errno.ENXIO:
-            trex_app.stdout_path = "/dev/null"
-            daemon_runner = ExtendedDaemonRunner(trex_app, trex_parser)
-        else:
-            raise
+    daemon_runner = ExtendedDaemonRunner(trex_app, trex_parser)
 
     #This ensures that the logger file handle does not get closed during daemonization
     daemon_runner.daemon_context.files_preserve=[handler.stream]
diff --git a/scripts/automation/trex_control_plane/server/trex_server.py b/scripts/automation/trex_control_plane/server/trex_server.py
index 7dee89e9..bf788d35 100755
--- a/scripts/automation/trex_control_plane/server/trex_server.py
+++ b/scripts/automation/trex_control_plane/server/trex_server.py
@@ -26,6 +26,7 @@ from trex_launch_thread import AsynchronousTRexSession
 from zmq_monitor_thread import ZmqMonitorSession
 from argparse import ArgumentParser, RawTextHelpFormatter
 from json import JSONEncoder
+import re
 
 
 # setup the logger
@@ -167,15 +168,17 @@ class CTRexServer(object):
         logger.info("Processing get_trex_daemon_log() command.")
         return self._pull_file('/var/log/trex/trex_daemon_server.log')
         
-    # get Trex version from ./t-rex-64 --help (last 4 lines)
+    # get Trex version from ./t-rex-64 --help (last lines starting with "Version : ...")
     def get_trex_version (self, base64 = True):
         try:
             logger.info("Processing get_trex_version() command.")
             if not self.trex_version:
                 help_print = subprocess.Popen(['./t-rex-64', '--help'], cwd = self.TREX_PATH, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-                help_print.wait()
-                help_print_stdout = help_print.stdout.read()
-                self.trex_version = binascii.b2a_base64('\n'.join(help_print_stdout.split('\n')[-5:-1]))
+                (stdout, stderr) = help_print.communicate()
+                search_result = re.search('\n\s*(Version\s*:.+)', stdout, re.DOTALL)
+                if not search_result:
+                    raise Exception('Could not determine version from ./t-rex-64 --help')
+                self.trex_version = binascii.b2a_base64(search_result.group(1))
             if base64:
                 return self.trex_version
             else:
@@ -256,7 +259,7 @@ class CTRexServer(object):
                 return False
 
             
-    def start_trex(self, trex_cmd_options, user, block_to_success = True, timeout = 30):
+    def start_trex(self, trex_cmd_options, user, block_to_success = True, timeout = 40):
         with self.start_lock:
             logger.info("Processing start_trex() command.")
             if self.is_reserved():
@@ -340,11 +343,12 @@ class CTRexServer(object):
 
         Parameters
         ----------
-        trex_cmd_options : str
-            Defines the exact command to run on the t-rex
-            Example: "-c 2 -m 0.500000 -d 100 -f cap2/sfr.yaml --nc  -p -l 1000"
+        kwargs: dictionary
+            Dictionary of parameters for trex. For example: (c=1, nc=True, l_pkt_mode=3).
+            Notice that when sending command line parameters that has -, you need to replace it with _.
+            for example, to have on command line "--l-pkt-mode 3", you need to send l_pkt_mode=3
         export_path : str
-            a full system path to which the results of the trex-run will be logged.
+            Full system path to which the results of the trex-run will be logged.
 
         """
         if 'results_file_path' in kwargs:
diff --git a/scripts/cap2/dns_no_delay.yaml b/scripts/cap2/dns_no_delay.yaml
new file mode 100644
index 00000000..ab387d31
--- /dev/null
+++ b/scripts/cap2/dns_no_delay.yaml
@@ -0,0 +1,23 @@
+- duration : 10.0
+  generator :  
+          distribution : "seq"
+          clients_start : "16.0.0.1"
+          clients_end   : "16.0.1.255"
+          servers_start : "48.0.0.1"
+          servers_end   : "48.0.0.255"
+          clients_per_gb : 201
+          min_clients    : 101
+          dual_port_mask : "1.0.0.0" 
+          tcp_aging      : 0
+          udp_aging      : 0
+  mac        : [0x00,0x00,0x00,0x01,0x00,0x00]
+  #vlan       : { enable : 1  ,  vlan0 : 100 , vlan1 : 200 }
+  #mac_override_by_ip : true
+  cap_info : 
+     - name: cap2/dns.pcap
+       cps : 1.0
+       ipg : 10000
+       rtt : 10000
+       w   : 1
+       
+
diff --git a/scripts/cap2/imix_64_100k.yaml b/scripts/cap2/imix_64_100k.yaml
new file mode 100644
index 00000000..0c2cfe14
--- /dev/null
+++ b/scripts/cap2/imix_64_100k.yaml
@@ -0,0 +1,70 @@
+#
+# Simple IMIX test 64B 
+#
+- duration : 3
+  generator :  
+          distribution : "seq"
+          clients_start : "16.0.0.1"
+          clients_end   : "16.0.0.255"
+          servers_start : "48.0.0.1"
+          servers_end   : "48.0.255.255"
+          clients_per_gb : 201
+          min_clients    : 101
+          dual_port_mask : "1.0.0.0" 
+          tcp_aging      : 0
+          udp_aging      : 0
+  mac        : [0x0,0x0,0x0,0x1,0x0,0x00]
+#
+# the templates are duplicated in purpose , to utilized all DRAM BW and get better performance, we should do it automaticly 
+# but for now it like this , you should have at least 8 
+#  
+  cap_info : 
+     - name: cap2/udp_64B.pcap
+       cps   : 1000.0
+       ipg   : 10000
+       rtt   : 10000
+       w     : 1
+       limit : 2000
+     - name: cap2/udp_64B.pcap
+       cps   : 1000.0
+       ipg   : 10000
+       rtt   : 10000
+       w     : 1
+       limit : 2000
+     - name: cap2/udp_64B.pcap
+       cps   : 1000.0
+       ipg   : 10000
+       rtt   : 10000
+       w     : 1
+       limit : 2000
+     - name: cap2/udp_64B.pcap
+       cps   : 1000.0
+       ipg   : 10000
+       rtt   : 10000
+       w     : 1
+       limit : 2000
+     - name: cap2/udp_64B.pcap
+       cps   : 1000.0
+       ipg   : 10000
+       rtt   : 10000
+       w     : 1
+       limit : 2000
+     - name: cap2/udp_64B.pcap
+       cps   : 1000.0
+       ipg   : 10000
+       rtt   : 10000
+       w     : 1
+       limit : 2000
+     - name: cap2/udp_64B.pcap
+       cps   : 1000.0
+       ipg   : 10000
+       rtt   : 10000
+       w     : 1
+       limit : 2000
+     - name: cap2/udp_64B.pcap
+       cps   : 1000.0
+       ipg   : 10000
+       rtt   : 10000
+       w     : 1
+       limit : 2000
+
diff --git a/scripts/cfg/simple_cfg.yaml b/scripts/cfg/simple_cfg.yaml
new file mode 100644
index 00000000..7b1dc393
--- /dev/null
+++ b/scripts/cfg/simple_cfg.yaml
@@ -0,0 +1,10 @@
+- port_limit      : 2         # this option can limit the number of port of the platform
+  version         : 2
+  interfaces    : ["03:00.0","03:00.1"] #the interfaces using ./dpdk_setup_ports.py -s 
+  port_info       :  # set eh mac addr 
+          - dest_mac        :   [0x00,0x00,0x00,0x01,0x00,0x00]    # router mac addr should be taken from router 
+            src_mac         :   [0x00,0x00,0x00,0x02,0x00,0x00]  # source mac-addr - taken from ifconfig
+          - dest_mac        :   [0x00,0x00,0x00,0x03,0x00,0x00]  # router mac addr  taken from router
+            src_mac         :   [0x00,0x00,0x00,0x04,0x00,0x00]  #source mac-addr  taken from ifconfig
+  
+
diff --git a/scripts/dpdk_nic_bind.py b/scripts/dpdk_nic_bind.py
index 08402227..f02454e5 100755
--- a/scripts/dpdk_nic_bind.py
+++ b/scripts/dpdk_nic_bind.py
@@ -32,7 +32,6 @@
 #   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 
-
 import sys, os, getopt, subprocess
 from os.path import exists, abspath, dirname, basename
 
@@ -44,7 +43,7 @@ ETHERNET_CLASS = "0200"
 # Each device within this is itself a dictionary of device properties
 devices = {}
 # list of supported DPDK drivers
-dpdk_drivers = [ "igb_uio", "vfio-pci" ]
+dpdk_drivers = [ "igb_uio", "vfio-pci", "uio_pci_generic" ]
 
 # command-line arg flags
 b_flag = None
@@ -69,7 +68,7 @@ Options:
     --help, --usage:
         Display usage information and quit
 
-    --status:
+    -s, --status:
         Print the current status of all known network interfaces.
         For each device, it displays the PCI domain, bus, slot and function,
         along with a text description of the device. Depending upon whether the
@@ -176,8 +175,11 @@ def check_modules():
 
     # check if we have at least one loaded module
     if True not in [mod["Found"] for mod in mods] and b_flag is not None:
-        print "Error - no supported modules are loaded"
-        sys.exit(1)
+        if b_flag in dpdk_drivers:
+            print "Error - no supported modules(DPDK driver) are loaded"
+            sys.exit(1)
+        else:
+            print "Warning - no supported modules(DPDK driver) are loaded"
 
     # change DPDK driver list to only contain drivers that are loaded
     dpdk_drivers = [mod["Name"] for mod in mods if mod["Found"]]
@@ -348,7 +350,6 @@ def bind_one(dev_id, driver, force):
             f = open(filename, "w")
         except:
             print "Error: bind failed for %s - Cannot open %s" % (dev_id, filename)
-            exit(-1)
             return
         try:
             f.write("%04x %04x" % (dev["Vendor"], dev["Device"]))
@@ -356,7 +357,6 @@ def bind_one(dev_id, driver, force):
         except:
             print "Error: bind failed for %s - Cannot write new PCI ID to " \
                 "driver %s" % (dev_id, driver)
-            exit(-1)
             return
 
     # do the bind by writing to /sys
@@ -391,7 +391,7 @@ def unbind_all(dev_list, force=False):
         unbind_one(d, force)
 
 def bind_all(dev_list, driver, force=False):
-    """Unbind method, takes a list of device locations"""
+    """Bind method, takes a list of device locations"""
     global devices
 
     dev_list = map(dev_id_from_dev_name, dev_list)
@@ -477,7 +477,7 @@ def parse_args():
         sys.exit(0)
 
     try:
-        opts, args = getopt.getopt(sys.argv[1:], "b:u",
+        opts, args = getopt.getopt(sys.argv[1:], "b:us",
                                ["help", "usage", "status", "force",
                                 "bind=", "unbind"])
     except getopt.GetoptError, error:
@@ -489,7 +489,7 @@ def parse_args():
         if opt == "--help" or opt == "--usage":
             usage()
             sys.exit(0)
-        if opt == "--status":
+        if opt == "--status" or opt == "-s":
             status_flag = True
         if opt == "--force":
             force_flag = True
diff --git a/scripts/exp/stl_vm_enable0-0-ex.erf b/scripts/exp/stl_vm_enable0-0-ex.erf
new file mode 100644
index 00000000..c6285be1
--- /dev/null
+++ b/scripts/exp/stl_vm_enable0-0-ex.erf
diff --git a/scripts/exp/stl_vm_enable1-0-ex.erf b/scripts/exp/stl_vm_enable1-0-ex.erf
new file mode 100644
index 00000000..d40539e9
--- /dev/null
+++ b/scripts/exp/stl_vm_enable1-0-ex.erf
diff --git a/scripts/exp/stl_vm_enable2-0-ex.erf b/scripts/exp/stl_vm_enable2-0-ex.erf
new file mode 100644
index 00000000..d099c14c
--- /dev/null
+++ b/scripts/exp/stl_vm_enable2-0-ex.erf
diff --git a/scripts/exp/udp_64B_vm6-ex.pcap b/scripts/exp/udp_64B_vm6-ex.pcap
new file mode 100644
index 00000000..68588302
--- /dev/null
+++ b/scripts/exp/udp_64B_vm6-ex.pcap
diff --git a/scripts/exp/udp_64B_vm7-ex.pcap b/scripts/exp/udp_64B_vm7-ex.pcap
new file mode 100644
index 00000000..a4498c06
--- /dev/null
+++ b/scripts/exp/udp_64B_vm7-ex.pcap
diff --git a/scripts/exp/udp_64B_vm8-ex.pcap b/scripts/exp/udp_64B_vm8-ex.pcap
new file mode 100644
index 00000000..b19bd0d0
--- /dev/null
+++ b/scripts/exp/udp_64B_vm8-ex.pcap
diff --git a/scripts/exp/udp_64B_vm9-ex.pcap b/scripts/exp/udp_64B_vm9-ex.pcap
new file mode 100644
index 00000000..7428e5d1
--- /dev/null
+++ b/scripts/exp/udp_64B_vm9-ex.pcap
diff --git a/scripts/run-gtest-clean b/scripts/run-gtest-clean
index c3f6ef9c..99994e31 100644
--- a/scripts/run-gtest-clean
+++ b/scripts/run-gtest-clean
@@ -1,2 +1,3 @@
 #! /bin/bash
-valgrind --leak-check=full --show-reachable=yes ./bp-sim-64 --ut --gtest_filter="basic_stl.*"
+valgrind --leak-check=full --show-reachable=yes ./bp-sim-64 --ut --gtest_filter="basic_*"
+
diff --git a/scripts/stl/imix_1pkt_2.yaml b/scripts/stl/imix_1pkt_2.yaml
new file mode 100644
index 00000000..163631dc
--- /dev/null
+++ b/scripts/stl/imix_1pkt_2.yaml
@@ -0,0 +1,38 @@
+### Single stream UDP packet, 64B ###
+#####################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []            
\ No newline at end of file
diff --git a/scripts/stl/imix_1pkt_tuple_gen.yaml b/scripts/stl/imix_1pkt_tuple_gen.yaml
new file mode 100644
index 00000000..78156e5c
--- /dev/null
+++ b/scripts/stl/imix_1pkt_tuple_gen.yaml
@@ -0,0 +1,63 @@
+### Single stream UDP packet, 64B ###
+#####################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+
+    # program that define 1M flows with IP range 16.0.0.1-16.0.0.254
+    # we will create a script that do that for you 
+    # this is the low level instructions 
+    vm: [
+               {
+                 "type" : "tuple_flow_var",   # name of the command 
+
+                 "name" : "tuple_gen",    # tuple_gen.ip tuple_gen.port can be used 
+
+                 "ip_min"   : 0x10000001,  # min ip 16.0.0.1
+                 "ip_max"   : 0x100000fe,  # max ip 16.0.0.254
+                  
+                 "port_min" : 1025,        # min port 1025     
+                 "port_max" : 65500,       # max port 65500
+                  
+                 "limit_flows" : 1000000,  # number of flows 
+                 "flags"       : 0,        # 1 - for unlimited  
+               },
+
+               {
+                  "type" : "write_flow_var", # command name 
+
+                  "name" : "tuple_gen.ip",  # varible to write     
+                  
+                  "add_value" : 0,          # no need to add value     
+                  
+                  "is_big_endian" : true,   # write as big edian 
+                  
+                  "pkt_offset" : 26,        # write tuple_gen.ip into ipv4.src_ip   
+               },
+               
+               {
+                  "type" : "fix_checksum_ipv4", # fix ipv4 header checksum 
+
+                  "pkt_offset" : 14,          # offset of ipv4 header 
+                  
+               },
+
+               {
+                  "type" : "write_flow_var", # command name 
+
+                  "name" : "tuple_gen.port",  # varible to write     
+                  
+                  "add_value" : 0,          # no need to add value     
+                  
+                  "is_big_endian" : true,   # write as big edian 
+                  
+                  "pkt_offset" : 34,        # write tuple_gen.port into udp.src_port
+               }
+
+        ]
diff --git a/scripts/stl/imix_1pkt_vm.yaml b/scripts/stl/imix_1pkt_vm.yaml
new file mode 100644
index 00000000..06517251
--- /dev/null
+++ b/scripts/stl/imix_1pkt_vm.yaml
@@ -0,0 +1,31 @@
+### Single stream UDP packet, 64B ###
+#####################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+
+    vm: [
+               {
+                  "init_value" : 0,
+                  "max_value" : 1000,
+                  "min_value" : 500,
+                  "name" : "l3_src",
+                  "op" : "inc",
+                  "size" : 4,
+                  "type" : "flow_var"
+               },
+               {
+                  "add_value" : 1,
+                  "is_big_endian" : false,
+                  "name" : "l3_src",
+                  "pkt_offset" : 34,
+                  "type" : "write_flow_var"
+               }
+
+        ]
diff --git a/scripts/stl/imix_3pkt.yaml b/scripts/stl/imix_3pkt.yaml
index 5405edb0..74ae41a8 100755
--- a/scripts/stl/imix_3pkt.yaml
+++ b/scripts/stl/imix_3pkt.yaml
@@ -7,7 +7,7 @@
       binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
     mode:
       type: continuous
-      pps: 100
+      pps: 28
     rx_stats: []
 - name: udp_594B
   stream:
@@ -16,7 +16,7 @@
       binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
     mode:
       type: continuous
-      pps: 100
+      pps: 20
     rx_stats: []
 - name: udp_1518B
   stream:
@@ -25,5 +25,5 @@
       binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
     mode:
       type: continuous
-      pps: 100
+      pps: 4
     rx_stats: []
\ No newline at end of file
diff --git a/scripts/stl/imix_scale_1000.yaml b/scripts/stl/imix_scale_1000.yaml
new file mode 100644
index 00000000..5b8d2123
--- /dev/null
+++ b/scripts/stl/imix_scale_1000.yaml
@@ -0,0 +1,28001 @@
+### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
\ No newline at end of file
diff --git a/scripts/stl/imix_scale_300.yaml b/scripts/stl/imix_scale_300.yaml
new file mode 100644
index 00000000..9ab578ff
--- /dev/null
+++ b/scripts/stl/imix_scale_300.yaml
@@ -0,0 +1,2801 @@
+### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ###
+#####################################################
+- name: udp_64B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_64B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_594B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_594B_no_crc.pcap  # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
+- name: udp_1518B
+  stream:
+    self_start: True
+    packet:
+      binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC
+    mode:
+      type: continuous
+      pps: 100
+    rx_stats: []
\ No newline at end of file
diff --git a/scripts/t-rex-64-debug b/scripts/t-rex-64-debug
index 4f3761d9..dafa0796 100755..120000
--- a/scripts/t-rex-64-debug
+++ b/scripts/t-rex-64-debug
@@ -1,9 +1 @@
-#! /bin/bash
-./trex-cfg
-cd $(dirname $0)
-export LD_LIBRARY_PATH=$PWD
-saveterm="$(stty -g)"
-./_$(basename $0) $@
-stty $saveterm  
-
-
+t-rex-64
\ No newline at end of file
diff --git a/scripts/t-rex-64-debug-o b/scripts/t-rex-64-debug-o
index 4f3761d9..dafa0796 100755..120000
--- a/scripts/t-rex-64-debug-o
+++ b/scripts/t-rex-64-debug-o
@@ -1,9 +1 @@
-#! /bin/bash
-./trex-cfg
-cd $(dirname $0)
-export LD_LIBRARY_PATH=$PWD
-saveterm="$(stty -g)"
-./_$(basename $0) $@
-stty $saveterm  
-
-
+t-rex-64
\ No newline at end of file
diff --git a/scripts/t-rex-64-o b/scripts/t-rex-64-o
index 4f3761d9..dafa0796 100755..120000
--- a/scripts/t-rex-64-o
+++ b/scripts/t-rex-64-o
@@ -1,9 +1 @@
-#! /bin/bash
-./trex-cfg
-cd $(dirname $0)
-export LD_LIBRARY_PATH=$PWD
-saveterm="$(stty -g)"
-./_$(basename $0) $@
-stty $saveterm  
-
-
+t-rex-64
\ No newline at end of file
diff --git a/src/bp_gtest.cpp b/src/bp_gtest.cpp
index a94c2d37..005801c4 100755
--- a/src/bp_gtest.cpp
+++ b/src/bp_gtest.cpp
@@ -31,6 +31,7 @@ limitations under the License.
 #include "msg_manager.h"
 #include <common/cgen_map.h>
 #include "platform_cfg.h"
+#include "latency.h"
 
 int test_policer(){
     CPolicer policer;
@@ -623,7 +624,6 @@ TEST_F(basic, test_pcap_mode1) {
      EXPECT_EQ_UINT32(1, res?1:0)<< "pass";
 }
 
-
 /* check override the low IPG */
 TEST_F(basic, test_pcap_mode2) {
 
@@ -638,154 +638,191 @@ TEST_F(basic, test_pcap_mode2) {
      EXPECT_EQ_UINT32(1, res?1:0)<< "pass";
 }
 
+#define l_pkt_test_s_ip 0x01020304
+#define l_pkt_test_d_ip 0x05060708
 
-
-
-
-TEST_F(basic, latency1) {
-    CLatencyPktInfo l;
-    l.Create();
-
-    CParserOption * po =&CGlobalInfo::m_options;
-    po->preview.setVMode(3);
-    po->preview.setFileWrite(true);
-
-    uint8_t  mac[]={0,0,0,1,0,0};
-    (void)mac;
-
-    CErfIF  erf_vif;
-    erf_vif.set_review_mode(&CGlobalInfo::m_options.preview);
-
-    erf_vif.open_file("exp/sctp.erf");
-
-
-    mac[0]=0;
-    mac[1]=0;
-    mac[2]=0;
-    mac[3]=1;
-    mac[4]=0;
-    mac[5]=0;
-
-
-    l.set_ip(0x10000000,0x20000000,0x01000000);
-
-    int i;
-    /* simulate 8 ports */
-    for (i=0;i<8; i++) {
-        rte_mbuf_t * m=l.generate_pkt(i);
-        erf_vif.send_node(l.getNode());
-        rte_pktmbuf_free(m);
-    }
-
-    erf_vif.close_file();
-
-
-    l.Delete();
-
-    CErfCmp cmp;
-    cmp.dump=1;
-
-    bool res=true;
-
-    if ( cmp.compare("exp/sctp.erf","exp/sctp-ex.erf") != true ) {
-        res=false;
+CLatencyPktMode *
+latency_pkt_mod_create(uint8_t l_pkt_mode) {
+    switch (l_pkt_mode) {
+    default:
+        return  new CLatencyPktModeSCTP(l_pkt_mode);
+        break;
+    case L_PKT_SUBMODE_NO_REPLY:
+    case L_PKT_SUBMODE_REPLY:
+    case L_PKT_SUBMODE_0_SEQ:
+        return new CLatencyPktModeICMP(l_pkt_mode);
+        break;
     }
-    EXPECT_EQ_UINT32((uint32_t)res?1:0, (uint32_t)1)<< "pass";
 }
 
-
-
-TEST_F(basic, latency2) {
-    CLatencyPktInfo l;
+rte_mbuf_t *
+create_latency_test_pkt(uint8_t l_pkt_mode, uint16_t &pkt_size, uint8_t port_id, uint8_t pkt_num) {
+    rte_mbuf_t * m;
+    CLatencyPktMode *c_l_pkt_mode;
     CCPortLatency port0;
-    l.Create();
-    port0.Create(0,0,l.get_payload_offset(),l.get_pkt_size(),0);
-
-
-    uint8_t  mac[]={0,0,0,1,0,0};
-    (void)mac;
-
-    mac[0]=0;
-    mac[1]=0;
-    mac[2]=0;
-    mac[3]=1;
-    mac[4]=0;
-    mac[5]=0;
-
-
-    l.set_ip(0x01000000,0x02000000,0x01000000);
-
-
-    int i;
-    for (i=0; i<100; i++) {
-        rte_mbuf_t * m=l.generate_pkt(0);
-        rte_pktmbuf_mtod(m, uint8_t*);
-        //utl_DumpBuffer(stdout,p,l.get_pkt_size(),0);
-
-        port0.update_packet(m);
+    CLatencyPktInfo info;
+    CLatencyManager mgr;
 
-        rte_pktmbuf_mtod(m, uint8_t*);
-        //utl_DumpBuffer(stdout,p,l.get_pkt_size(),0);
-        //printf("offset is : %d \n",l.get_payload_offset());
+    c_l_pkt_mode = latency_pkt_mod_create(l_pkt_mode);
 
-        CRx_check_header *  rx_p;
-        bool res=port0.check_packet(m,rx_p);
-        EXPECT_EQ_UINT32((uint32_t)res?1:0, (uint32_t)1)<< "pass";
-        if (!res ) {
-            printf(" ERROR \n");
+    mgr.c_l_pkt_mode = c_l_pkt_mode;
+    info.Create(c_l_pkt_mode);
+    port0.Create(&mgr, 0, info.get_payload_offset(), info.get_l4_offset(), info.get_pkt_size(), 0);
+    info.set_ip(l_pkt_test_s_ip ,l_pkt_test_d_ip, 0x01000000);
+    m=info.generate_pkt(0);
+    while (pkt_num > 0) {
+        pkt_num--;
+        port0.update_packet(m, port_id);
+    }
+    pkt_size = info.get_pkt_size();
+    port0.Delete();
+    info.Delete();
+    delete c_l_pkt_mode;
+
+    return m;
+}
+
+bool
+verify_latency_pkt(uint8_t *p, uint8_t proto, uint16_t icmp_seq, uint8_t icmp_type) {
+    EthernetHeader *eth = (EthernetHeader *)p;
+    IPHeader *ip = (IPHeader *)(p + 14);
+    uint8_t  srcmac[]={0,0,0,1,0,0};    
+    uint8_t  dstmac[]={0,0,0,1,0,0};
+    latency_header * h;
+ 
+    // eth
+    EXPECT_EQ_UINT32(eth->getNextProtocol(), 0x0800)<< "Failed ethernet next protocol check";
+    EXPECT_EQ_UINT32(memcmp(p, srcmac, 6), 0)<<  "Failed ethernet source MAC check";
+    EXPECT_EQ_UINT32(memcmp(p, dstmac, 6), 0)<<  "Failed ethernet dest MAC check";
+    // IP
+    EXPECT_EQ_UINT32(ip->getSourceIp(), l_pkt_test_s_ip)<<  "Failed IP src check";
+    EXPECT_EQ_UINT32(ip->getDestIp(), l_pkt_test_d_ip)<<  "Failed IP dst check";
+    EXPECT_EQ_UINT32(ip->getProtocol(), proto)<<  "Failed IP protocol check";
+    EXPECT_EQ_UINT32(ip->isChecksumOK()?0:1, 0)<<  "Failed IP checksum check";
+    EXPECT_EQ_UINT32(ip->getTimeToLive(), 0xff)<<  "Failed IP ttl check";
+    EXPECT_EQ_UINT32(ip->getTotalLength(), 48)<<  "Failed IP total length check";
+    
+    // payload
+    h=(latency_header *)(p+42);
+    EXPECT_EQ_UINT32(h->magic, LATENCY_MAGIC)<<  "Failed latency magic check";
+
+    if (proto == 0x84)
+        return true;
+    // ICMP
+    ICMPHeader *icmp = (ICMPHeader *)(p + 34);
+    EXPECT_EQ_UINT32(icmp->isCheckSumOk(28)?0:1, 0)<<  "Failed ICMP checksum verification";
+    EXPECT_EQ_UINT32(icmp->getSeqNum(), icmp_seq)<< "Failed ICMP sequence number check";
+    EXPECT_EQ_UINT32(icmp->getType(), icmp_type)<<  "Failed ICMP type check";
+    EXPECT_EQ_UINT32(icmp->getCode(), 0)<<  "Failed ICMP code check";
+    EXPECT_EQ_UINT32(icmp->getId(), 0xaabb)<<  "Failed ICMP ID check";
+
+    return true;
+}
+
+bool
+test_latency_pkt_rcv(rte_mbuf_t *m, uint8_t l_pkt_mode, uint8_t port_num, uint16_t num_pkt, bool exp_pkt_ok
+                     , uint16_t exp_tx_seq, uint16_t exp_rx_seq) {
+    CLatencyPktMode *c_l_pkt_mode;
+    CCPortLatency port;
+    CLatencyPktInfo info;
+    CLatencyManager mgr;
+    CRx_check_header *rxc;
+    CGlobalInfo::m_options.m_l_pkt_mode = l_pkt_mode;
+
+    c_l_pkt_mode = latency_pkt_mod_create(l_pkt_mode);
+    mgr.c_l_pkt_mode = c_l_pkt_mode;
+    info.Create(c_l_pkt_mode);
+    port.Create(&mgr, 0, info.get_payload_offset(), info.get_l4_offset(), info.get_pkt_size(), 0);
+    bool pkt_ok = port.check_packet(m, rxc);
+
+    while (num_pkt > 0) {
+        num_pkt--;
+        if (port.can_send_packet(port_num)) {
+            port.update_packet(m, 0);
         }
-        rte_pktmbuf_free(m);
     }
-    port0.DumpCounters(stdout);
-    EXPECT_EQ_UINT32(port0.m_pkt_ok, (uint32_t)100)<< "pass";
 
-    port0.Delete();
-    l.Delete();
+    EXPECT_EQ_UINT32(pkt_ok ?0:1, exp_pkt_ok?0:1)<<  "Failed packet OK check";
+    EXPECT_EQ_UINT32(port.get_icmp_tx_seq(), exp_tx_seq)<<  "Failed tx check";
+    EXPECT_EQ_UINT32(port.get_icmp_rx_seq(), exp_rx_seq)<<  "Failed rx check";
+    // if packet is bad, check_packet raise the error counter
+    EXPECT_EQ_UINT32(port.m_unsup_prot, exp_pkt_ok?0:1)<<  "Failed unsupported packets count";
+
+    return true;
 }
 
 
-TEST_F(basic, latency3) {
-    CLatencyPktInfo l;
-    CCPortLatency port0;
-    l.Create();
-    port0.Create(0,0,l.get_payload_offset(),l.get_pkt_size(),0);
+// Testing latency packet generation
+TEST_F(basic, latency1) {
+    uint8_t *p;
+    rte_mbuf_t * m;
+    uint16_t pkt_size;
 
+    // SCTP packet
+    m = create_latency_test_pkt(0, pkt_size, 0, 1);
+    p=rte_pktmbuf_mtod(m, uint8_t*);
+    verify_latency_pkt(p, 0x84, 0, 0);
+    rte_pktmbuf_free(m);
 
-    uint8_t  mac[]={0,0,0,1,0,0};
-    (void)mac;
+    m = create_latency_test_pkt(L_PKT_SUBMODE_NO_REPLY, pkt_size, 1, 2);
+    p=rte_pktmbuf_mtod(m, uint8_t*);
+    verify_latency_pkt(p, 0x01, 2, 8);
+    rte_pktmbuf_free(m);
 
+    // ICMP reply mode client side
+    m = create_latency_test_pkt(L_PKT_SUBMODE_REPLY, pkt_size, 0, 3);
+    p = rte_pktmbuf_mtod(m, uint8_t*);
+    verify_latency_pkt(p, 0x01, 3, 8);
+    rte_pktmbuf_free(m);
 
-    mac[0]=0;
-    mac[1]=0;
-    mac[2]=0;
-    mac[3]=1;
-    mac[4]=0;
-    mac[5]=0;
+    // ICMP reply mode server side
+    m = create_latency_test_pkt(L_PKT_SUBMODE_REPLY, pkt_size, 1, 4);
+    p=rte_pktmbuf_mtod(m, uint8_t*);
+    verify_latency_pkt(p, 0x01, 4, 0);
+    rte_pktmbuf_free(m);
 
+    m = create_latency_test_pkt(L_PKT_SUBMODE_0_SEQ, pkt_size, 1, 5);
+    p=rte_pktmbuf_mtod(m, uint8_t*);
+    verify_latency_pkt(p, 0x01, 0, 8);
+    rte_pktmbuf_free(m);
+}
 
-    l.set_ip(0x01000000,0x02000000,0x01000000);
+// Testing latency packet receive path
+TEST_F(basic, latency2) {
+    rte_mbuf_t *m;
+    uint16_t pkt_size;
+    uint8_t port_id = 0;
+    uint8_t pkt_num = 1;
+    uint8_t l_pkt_mode;
 
-    uint8_t *p;
-    rte_mbuf_t * m=l.generate_pkt(0);
-    port0.update_packet(m);
-    p=rte_pktmbuf_mtod(m, uint8_t*);
-    memset(p,0,l.get_pkt_size());
+    l_pkt_mode = 0;
+    m = create_latency_test_pkt(l_pkt_mode, pkt_size, port_id, pkt_num);
+    test_latency_pkt_rcv(m, l_pkt_mode, 0, 2, true, 1, 0);
 
-    CRx_check_header *  rx_p;
-    bool res=port0.check_packet(m,rx_p);
-    EXPECT_EQ_UINT32((uint32_t)res?0:1, (uint32_t)1)<< "pass";
-    if (!res ) {
-        printf(" OK \n");
-    }
-    rte_pktmbuf_free(m);
-    EXPECT_EQ_UINT32(port0.m_unsup_prot, (uint32_t)1)<< "pass";
+    l_pkt_mode = L_PKT_SUBMODE_NO_REPLY;
+    m = create_latency_test_pkt(l_pkt_mode, pkt_size, port_id, pkt_num);
+    test_latency_pkt_rcv(m, l_pkt_mode, 1, 2, true, 3, 1);
 
-    port0.Delete();
-    l.Delete();
-}
+    // reply mode server
+    l_pkt_mode = L_PKT_SUBMODE_REPLY;
+    m = create_latency_test_pkt(l_pkt_mode, pkt_size, port_id, pkt_num);
+    test_latency_pkt_rcv(m, l_pkt_mode, 1, 2, true, 2, 1);
 
+    // reply mode client
+    l_pkt_mode = L_PKT_SUBMODE_REPLY;
+    m = create_latency_test_pkt(l_pkt_mode, pkt_size, port_id, pkt_num);
+    test_latency_pkt_rcv(m, l_pkt_mode, 0, 2, true, 3, 1);
 
+    l_pkt_mode = L_PKT_SUBMODE_0_SEQ;
+    m = create_latency_test_pkt(l_pkt_mode, pkt_size, port_id, pkt_num);
+    test_latency_pkt_rcv(m, l_pkt_mode, 0, 2, true, 0, 0);
 
+    // bad packet
+    m = create_latency_test_pkt(l_pkt_mode, pkt_size, port_id, pkt_num);
+    EthernetHeader *eth = (EthernetHeader *)rte_pktmbuf_mtod(m, uint8_t*);
+    eth->setNextProtocol(0x5);
+    test_latency_pkt_rcv(m, l_pkt_mode, 0, 2, false, 1, 0);
+}
 
 class CDummyLatencyHWBase : public CPortLatencyHWBase {
 public:
@@ -835,21 +872,8 @@ public:
     uint8_t      m_port_id;
 };
 
-
-
-TEST_F(basic, latency4) {
-
-    uint8_t  mac[]={0,0,0,1,0,0};
-    (void)mac;
-    
-    mac[0]=0;
-    mac[1]=0;
-    mac[2]=0;
-    mac[3]=1;
-    mac[4]=0;
-    mac[5]=0;
-
-    
+// Testing latency statistics functions
+TEST_F(basic, latency3) {
     CLatencyManager mg;
     CLatencyManagerCfg  cfg;
     CDummyLatencyHWBase dports[MAX_LATENCY_PORTS];
@@ -882,7 +906,6 @@ TEST_F(basic, latency4) {
     mg.Delete();
 }
 
-
 TEST_F(basic, hist1) {
 
     CTimeHistogram  hist1;
@@ -902,8 +925,6 @@ TEST_F(basic, hist1) {
     hist1.Delete();
 }
 
-
-
 TEST_F(basic, rtsp1) {
 
      CTestBasic t1;
@@ -2020,7 +2041,7 @@ public:
     virtual int send_node(CGenNode * node);
 
 
-    virtual int update_mac_addr_from_global_cfg(pkt_dir_t       dir, rte_mbuf_t      *m){
+    virtual int update_mac_addr_from_global_cfg(pkt_dir_t       dir, uint8_t * p){
         return (0);
     }
 
diff --git a/src/bp_sim.cpp b/src/bp_sim.cpp
index a61fbb8f..081553b5 100755
--- a/src/bp_sim.cpp
+++ b/src/bp_sim.cpp
@@ -20,6 +20,7 @@ limitations under the License.
 */
 
 #include "bp_sim.h"
+#include "latency.h"
 #include "utl_json.h"
 #include "utl_yaml.h"
 #include "msg_manager.h"
@@ -1311,7 +1312,6 @@ bool CPacketIndication::ConvertPacketToIpv6InPlace(CCapPktRaw * pkt,
     return (true);
 }
 
-
 void CPacketIndication::ProcessPacket(CPacketParser *parser,
                                       CCapPktRaw * pkt){
     _ProcessPacket(parser,pkt);
@@ -1320,8 +1320,6 @@ void CPacketIndication::ProcessPacket(CPacketParser *parser,
     }
 }
 
-
-
 /* process packet */
 void CPacketIndication::_ProcessPacket(CPacketParser *parser,
                                       CCapPktRaw * pkt){
@@ -4657,13 +4655,24 @@ int CErfIFStl::send_node(CGenNode * _no_to_use){
     if ( m_preview_mode->getFileWrite() ){
 
         CGenNodeStateless * node_sl=(CGenNodeStateless *) _no_to_use;
-    
+
+        pkt_dir_t dir=(pkt_dir_t)node_sl->get_mbuf_cache_dir();
+
         /* check that we have mbuf  */
         rte_mbuf_t *    m=node_sl->get_cache_mbuf();
-        assert( m );
-        pkt_dir_t dir=(pkt_dir_t)node_sl->get_mbuf_cache_dir();
+        if (m) {
+            /* cache packet */
+            fill_raw_packet(m,_no_to_use,dir);
+            /* can't free the m, it is cached*/
+        }else{
+
+            m=node_sl->alloc_node_with_vm();
+            assert(m);
+            fill_raw_packet(m,_no_to_use,dir);
+            rte_pktmbuf_free(m);
+
+        }
     
-        fill_raw_packet(m,_no_to_use,dir);
         BP_ASSERT(m_writer);
         bool res=m_writer->write_packet(m_raw);
     
@@ -4719,900 +4728,10 @@ int CErfIF::send_node(CGenNode * node){
    return (0);
 }
 
-
 int CErfIF::flush_tx_queue(void){
     return (0);
 }
 
-
-
-const uint8_t sctp_pkt[]={ 
-
-    0x00,0x04,0x96,0x08,0xe0,0x40,
-    0x00,0x0e,0x2e,0x24,0x37,0x5f,
-    0x08,0x00,
-
-    0x45,0x02,0x00,0x30,
-    0x00,0x00,0x40,0x00,
-    0x40,0x84,0xbd,0x04,
-    0x9b,0xe6,0x18,0x9b, //sIP
-    0xcb,0xff,0xfc,0xc2, //DIP
-
-    0x80,0x44,//SPORT
-    0x00,0x50,//DPORT
-
-    0x00,0x00,0x00,0x00, //checksum 
-
-    0x11,0x22,0x33,0x44, // magic 
-    0x00,0x00,0x00,0x00, //64 bit counter
-    0x00,0x00,0x00,0x00,
-    0x00,0x01,0xa0,0x00, //seq
-    0x00,0x00,0x00,0x00,
-
-};
-
-// 20+8+20`
-
-void CLatencyPktInfo::Create(){
-    m_packet = new CCapPktRaw( sizeof(sctp_pkt) );
-    m_packet->pkt_cnt=0;
-    m_packet->time_sec=0;
-    m_packet->time_nsec=0;
-    memcpy(m_packet->raw,sctp_pkt,sizeof(sctp_pkt));
-    m_packet->pkt_len=sizeof(sctp_pkt);
-
-    m_pkt_indication.m_packet  =m_packet;
-
-    m_pkt_indication.m_ether = (EthernetHeader *)m_packet->raw;
-    m_pkt_indication.l3.m_ipv4=(IPHeader       *)(m_packet->raw+14);
-    m_pkt_indication.m_is_ipv6 = false;
-    m_pkt_indication.l4.m_udp=(UDPHeader *)m_packet->raw+14+20;
-    m_pkt_indication.m_payload=(uint8_t *)m_packet->raw+14+20+16;
-    m_pkt_indication.m_payload_len=0;
-    m_pkt_indication.m_packet_padding=4;
-
-
-    m_pkt_indication.m_ether_offset =0;
-    m_pkt_indication.m_ip_offset =14;
-    m_pkt_indication.m_udp_tcp_offset = 34;
-    m_pkt_indication.m_payload_offset = 34+8;
-
-    CPacketDescriptor * lpd=&m_pkt_indication.m_desc;
-    lpd->Clear();
-    lpd->SetInitSide(true);
-    lpd->SetSwapTuple(false);
-    lpd->SetIsValidPkt(true);
-    lpd->SetIsUdp(true);
-    lpd->SetIsLastPkt(true);
-    m_pkt_info.Create(&m_pkt_indication);
-
-    memset(&m_dummy_node,0,sizeof(m_dummy_node));
-
-    m_dummy_node.set_socket_id( CGlobalInfo::m_socket.port_to_socket(0) );
-
-    m_dummy_node.m_time =0.1;
-    m_dummy_node.m_pkt_info = &m_pkt_info;
-    m_dummy_node.m_dest_ip  = 0;
-    m_dummy_node.m_src_ip   = 0;
-    m_dummy_node.m_src_port =  0x11;
-    m_dummy_node.m_flow_id =0;
-    m_dummy_node.m_flags =CGenNode::NODE_FLAGS_LATENCY;
-    
-}
-
-
-rte_mbuf_t * CLatencyPktInfo::generate_pkt(int port_id,uint32_t extern_ip){
-
-    bool is_client_to_serever=(port_id%2==0)?true:false;
-
-    int dual_port_index=(port_id>>1);
-    uint32_t c=m_client_ip.v4;
-    uint32_t s=m_server_ip.v4;
-    if ( extern_ip ){
-        c=extern_ip;
-    }
-
-    if (!is_client_to_serever) {
-        /*swap */
-        uint32_t t=c;
-        c=s;
-        s=t;
-    }
-    uint32_t mask=dual_port_index*m_dual_port_mask;
-    if ( extern_ip==0 ){
-       c+=mask;
-    }
-    s+=mask;
-    m_dummy_node.m_src_ip  = c;
-    m_dummy_node.m_dest_ip   = s;
-
-    rte_mbuf_t * m=m_pkt_info.generate_new_mbuf(&m_dummy_node);
-    return (m);
-
-
-}
-
-
-void CLatencyPktInfo::set_ip(uint32_t src,
-                             uint32_t dst,
-                             uint32_t dual_port_mask){
-
-    m_client_ip.v4=src;
-    m_server_ip.v4=dst;
-    m_dual_port_mask=dual_port_mask;
-
-}
-
-
-void CLatencyPktInfo::Delete(){
-    m_pkt_info.Delete();
-    delete m_packet;
-}
-
-void CCPortLatency::reset(){
-    m_rx_seq    =m_tx_seq;
-    m_pad       = 0;
-
-    m_tx_pkt_err=0;
-    m_tx_pkt_ok =0;
-    m_pkt_ok=0;
-    m_rx_check=0;
-    m_no_magic=0;
-    m_unsup_prot=0;
-    m_no_id=0;
-    m_seq_error=0;
-    m_length_error=0;
-    m_no_ipv4_option=0;
-    m_hist.Reset();
-}
-
-
-static uint8_t nat_is_port_can_send(uint8_t port_id){
-    uint8_t client_index = (port_id %2);
-    return (client_index ==0 ?1:0);
-}
-
-
-bool CCPortLatency::Create(CLatencyManager * parent,
-                           uint8_t id,
-                           uint16_t offset,
-                           uint16_t pkt_size,
-                           CCPortLatency * rx_port){
-    m_parent    = parent;
-    m_id        = id;
-    m_tx_seq    =0x12345678;
-    m_offset    = offset;
-    m_pkt_size  = pkt_size;
-    m_rx_port   = rx_port;
-    m_nat_can_send = nat_is_port_can_send(m_id);
-    m_nat_learn    = m_nat_can_send;
-    m_nat_external_ip=0;
-
-    m_hist.Create();
-    reset();
-    return (true);
-}
-
-void CCPortLatency::Delete(){
-    m_hist.Delete();
-}
-
-void CCPortLatency::update_packet(rte_mbuf_t * m){
-    uint8_t *p=rte_pktmbuf_mtod(m, uint8_t*);
-    /* update mac addr dest/src 12 bytes */
-    memcpy(p,CGlobalInfo::m_options.get_dst_src_mac_addr(m_id),12);
-
-    latency_header * h=(latency_header *)(p+m_offset);
-    h->magic = LATENCY_MAGIC | m_id ;
-    h->time_stamp = os_get_hr_tick_64();
-    h->seq = m_tx_seq;
-    m_tx_seq++;
-}
-
-
-void CCPortLatency::DumpShortHeader(FILE *fd){
-    
-
-    fprintf(fd," if|   tx_ok , rx_ok  , rx   ,error,    average   ,   max         , Jitter ,  max window \n");
-	fprintf(fd,"   |         ,        , check,     , latency(usec),latency (usec) ,(usec)  ,             \n");
-    fprintf(fd," ---------------------------------------------------------------------------------------------------------------- \n");
-}
-
-
-
-std::string CCPortLatency::get_field(std::string name,float f){
-    char buff[200];
-    sprintf(buff,"\"%s-%d\":%.1f,",name.c_str(),m_id,f);
-    return (std::string(buff));
-}
-
-
-void CCPortLatency::dump_json_v2(std::string & json ){
-    char buff[200];
-    sprintf(buff,"\"port-%d\": {",m_id);
-    json+=std::string(buff);
-    m_hist.dump_json("hist",json);
-    dump_counters_json(json);
-    json+="},";
-}
-
-void CCPortLatency::dump_json(std::string & json ){
-    json += get_field("avg",m_hist.get_average_latency() );
-    json += get_field("max",m_hist.get_max_latency() );
-    json += get_field("c-max",m_hist.get_max_latency_last_update() );
-    json += get_field("error",(float)(m_unsup_prot+m_no_magic+m_no_id+m_seq_error+m_length_error) );
-    json += get_field("jitter",(float)get_jitter_usec() );
-}
-
-
-void CCPortLatency::DumpShort(FILE *fd){
-
-	m_hist.update();
-    fprintf(fd,"%8lu,%8lu,%10lu,%4lu,",                          
-                    m_tx_pkt_ok,
-                    m_pkt_ok,
-                    m_rx_check,
-                    m_unsup_prot+m_no_magic+m_no_id+m_seq_error+m_length_error+m_no_ipv4_option+m_tx_pkt_err
-            );
-
-    fprintf(fd,"   %8.0f  ,%8.0f,%8d ",
-                          m_hist.get_average_latency(),
-                          m_hist.get_max_latency(),
-                          get_jitter_usec()
-                        );
-	fprintf(fd,"     | ");
-	m_hist.DumpWinMax(fd);
-
-}
-
-#define DPL_J(f)  json+=add_json(#f,f);
-#define DPL_J_LAST(f)  json+=add_json(#f,f,true);
-
-void CCPortLatency::dump_counters_json(std::string & json ){
-
-    json+="\"stats\" : {";
-    DPL_J(m_tx_pkt_ok);
-    DPL_J(m_tx_pkt_err);
-    DPL_J(m_pkt_ok);
-    DPL_J(m_unsup_prot);
-    DPL_J(m_no_magic);
-    DPL_J(m_no_id);
-    DPL_J(m_seq_error);
-    DPL_J(m_length_error);
-    DPL_J(m_no_ipv4_option);
-    json+=add_json("m_jitter",get_jitter_usec());
-    /* must be last */
-    DPL_J_LAST(m_rx_check);
-    json+="}";
-
-
-}
-
-void CCPortLatency::DumpCounters(FILE *fd){
-    #define DP_A1(f) if (f) fprintf(fd," %-40s : %llu \n",#f, (unsigned long long)f)
-
-    fprintf(fd," counter  \n");
-    fprintf(fd," -----------\n");
-
-    DP_A1(m_tx_pkt_err);
-    DP_A1(m_tx_pkt_ok);
-    DP_A1(m_pkt_ok);
-    DP_A1(m_unsup_prot);
-    DP_A1(m_no_magic);
-    DP_A1(m_no_id);
-    DP_A1(m_seq_error);
-    DP_A1(m_length_error);
-    DP_A1(m_rx_check);
-    DP_A1(m_no_ipv4_option);
-
-
-    fprintf(fd," -----------\n");
-    m_hist.Dump(fd);
-    fprintf(fd," %-40s : %lu \n","jitter", (ulong)get_jitter_usec());
-}
-
-bool CCPortLatency::dump_packet(rte_mbuf_t * m){
-    fprintf(stdout," %f.03 dump packet ..\n",now_sec());
-	uint8_t *p=rte_pktmbuf_mtod(m, uint8_t*);
-	uint16_t pkt_size=rte_pktmbuf_pkt_len(m);
-    utl_DumpBuffer(stdout,p,pkt_size,0);
-    return (0);
-
-
-
-    if (pkt_size < ( sizeof(CRx_check_header)+14+20) ) {
-        assert(0);
-    }
-    CRx_check_header * lp=(CRx_check_header *)(p+pkt_size-sizeof(CRx_check_header));
-
-    lp->dump(stdout);
-
-
-	uint16_t vlan_offset=0;
-	if ( unlikely( CGlobalInfo::m_options.preview.get_vlan_mode_enable() ) ){
-		vlan_offset=4;
-	}
-
-    (void)vlan_offset;
-
-//	utl_DumpBuffer(stdout,p,pkt_size,0);
-	return (0);
-
-}
-
-bool CCPortLatency::check_rx_check(rte_mbuf_t * m){
-    m_rx_check++;
-    return (true);
-}
-
-bool CCPortLatency::do_learn(uint32_t external_ip){
-    m_nat_learn=true;
-    m_nat_can_send=true;
-    m_nat_external_ip=external_ip;
-    return (true);
-}
-
-bool CCPortLatency::check_packet(rte_mbuf_t * m,CRx_check_header * & rx_p){
-
-    CSimplePacketParser parser(m);
-    if ( !parser.Parse()  ){
-        m_unsup_prot++;  // Unsupported protocol
-        return (false);
-    }
-    
-    uint16_t pkt_size=rte_pktmbuf_pkt_len(m);
-    /* check if CRC was extracted */
-    if ( parser.getPktSize() == pkt_size-4) {
-        // CRC was not extracted by driver (VM E1000 driver issue) extract it
-        pkt_size=pkt_size-4;
-    }
-
-    uint16_t vlan_offset=parser.m_vlan_offset;
-    uint8_t *p=rte_pktmbuf_mtod(m, uint8_t*);
-
-    rx_p = (CRx_check_header *)0;
-
-    if ( !parser.IsLatencyPkt() ){
-
-        #ifdef NAT_TRACE_
-        printf(" %.3f RX : got packet !!! \n",now_sec() );
-        #endif
-
-        /* ipv6+rx-check */
-        if ( parser.m_ipv6 ) {
-            /* if we have ipv6 packet */
-            if (parser.m_protocol == RX_CHECK_V6_OPT_TYPE) {
-                if ( get_is_rx_check_mode() ){
-                    m_rx_check++;
-                    rx_p=(CRx_check_header *)((uint8_t*)parser.m_ipv6  +IPv6Header::DefaultSize);
-                    return (true);
-                }
-
-            }
-            m_seq_error++;
-           return (false);
-        }
-
-        uint8_t opt_len = parser.m_ipv4->getOptionLen();
-        uint8_t *opt_ptr = parser.m_ipv4->getOption();
-        /* Process IP option header(s) */
-        while ( opt_len != 0 ) {
-            switch (*opt_ptr) {
-            case RX_CHECK_V4_OPT_TYPE:
-                    /* rx-check option header */
-                    if ( ( !get_is_rx_check_mode() ) ||
-                        (opt_len < RX_CHECK_LEN) ) {
-                        m_seq_error++;
-                        return (false);
-                    }
-                    m_rx_check++;
-                    rx_p=(CRx_check_header *)opt_ptr;
-                    opt_len -= RX_CHECK_LEN;
-                    opt_ptr += RX_CHECK_LEN;
-                    break;
-            case CNatOption::noIPV4_OPTION:
-                    /* NAT learn option header */
-                    CNatOption *lp;
-                    if ( ( !CGlobalInfo::is_learn_mode() ) ||
-                         (opt_len < CNatOption::noOPTION_LEN) ) {
-                        m_seq_error++;
-                        return (false);
-                    }
-                    lp = (CNatOption *)opt_ptr;
-                    if ( !lp->is_valid_ipv4_magic() ) {
-                        m_no_ipv4_option++;
-                        return (false);
-                    }
-                    m_parent->get_nat_manager()->handle_packet_ipv4(lp,parser.m_ipv4);
-                    opt_len -= CNatOption::noOPTION_LEN;
-                    opt_ptr += CNatOption::noOPTION_LEN;
-                    break;
-            default:
-                    m_seq_error++;
-                    return (false);
-            } // End of switch
-        } // End of while
-
-        return (true);
-    } // End of check for non-latency packet
-
-    if ( CGlobalInfo::is_learn_mode() && (m_nat_learn ==false) ) {
-        do_learn(parser.m_ipv4->getSourceIp());
-    }
-
-    if ( (pkt_size-vlan_offset) != m_pkt_size ) {
-        m_length_error++;
-        return (false);
-    }
-
-    latency_header * h=(latency_header *)(p+m_offset+vlan_offset);
-
-    if ( (h->magic & 0xffffff00) != LATENCY_MAGIC ){
-        m_no_magic++;
-        return (false);
-    }
-
-    if ( h->seq != m_rx_seq ){
-        m_seq_error++;
-        m_rx_seq =h->seq +1;
-        return (false);
-    }else{
-        m_rx_seq++;
-    }
-    m_pkt_ok++;
-    uint64_t d = (os_get_hr_tick_64() - h->time_stamp );
-    dsec_t ctime=ptime_convert_hr_dsec(d);
-    m_hist.Add(ctime);
-    m_jitter.calc(ctime);
-    return (true);
-}
-
-void CLatencyManager::Delete(){
-    m_pkt_gen.Delete();
-
-    if ( get_is_rx_check_mode() ) {
-        m_rx_check_manager.Delete();
-    }
-    if ( CGlobalInfo::is_learn_mode() ){
-        m_nat_check_manager.Delete();
-    }
-    m_cpu_cp_u.Delete();
-}
-
-/* 0->1
-   1->0 
-   2->3
-   3->2
-*/
-static uint8_t swap_port(uint8_t port_id){
-    uint8_t offset= ((port_id>>1)<<1);
-    uint8_t client_index = (port_id %2);
-    return (offset + (client_index ^ 1));
-}
-
-
-
-bool CLatencyManager::Create(CLatencyManagerCfg * cfg){
-    m_max_ports=cfg->m_max_ports;
-    assert (m_max_ports<=MAX_LATENCY_PORTS);
-    assert ((m_max_ports%2)==0);
-    m_port_mask =0xffffffff;
-    m_do_stop =false;
-    m_is_active =false;
-    m_pkt_gen.Create();
-    int i;
-    for (i=0; i<m_max_ports; i++) {
-        CLatencyManagerPerPort * lp=&m_ports[i];
-        CCPortLatency * lpo=&m_ports[swap_port(i)].m_port;
-
-        lp->m_io=cfg->m_ports[i];
-        lp->m_port.Create(this,
-                          i,
-                          m_pkt_gen.get_payload_offset(),
-                          m_pkt_gen.get_pkt_size(),lpo );
-    }
-    m_cps= cfg->m_cps;
-    m_d_time =ptime_convert_dsec_hr((1.0/m_cps));
-    m_delta_sec =(1.0/m_cps);
-
-        
-    if ( get_is_rx_check_mode() ) {
-        assert(m_rx_check_manager.Create());
-        m_rx_check_manager.m_cur_time= now_sec();
-     }
-
-
-    m_pkt_gen.set_ip(cfg->m_client_ip.v4,cfg->m_server_ip.v4,cfg->m_dual_port_mask);
-    m_cpu_cp_u.Create(&m_cpu_dp_u);
-    if ( CGlobalInfo::is_learn_mode() ){
-        m_nat_check_manager.Create();
-    }
-    return (true);
-}
-
-
-void  CLatencyManager::send_pkt_all_ports(){
-    m_start_time = os_get_hr_tick_64();
-    int i;
-    for (i=0; i<m_max_ports; i++) {
-        if ( m_port_mask & (1<<i)  ){
-            CLatencyManagerPerPort * lp=&m_ports[i];
-            if (lp->m_port.can_send_packet() ){
-                rte_mbuf_t * m=m_pkt_gen.generate_pkt(i,lp->m_port.external_nat_ip());
-                lp->m_port.update_packet(m);
-                if ( lp->m_io->tx(m) == 0 ){
-                    lp->m_port.m_tx_pkt_ok++;
-                }else{
-                    lp->m_port.m_tx_pkt_err++;
-                }
-
-            }
-        }
-    }
-}
-
-
-void  CLatencyManager::wait_for_rx_dump(){
-	rte_mbuf_t * rx_pkts[64];
-	int i;
-	while ( true  ) {
-		rte_pause();
-		rte_pause();
-		rte_pause();
-		for (i=0; i<m_max_ports; i++) {
-			CLatencyManagerPerPort * lp=&m_ports[i];
-			rte_mbuf_t * m;
-			uint16_t cnt_p = lp->m_io->rx_burst(rx_pkts, 64);
-			if (cnt_p) {
-				int j;
-				for (j=0; j<cnt_p; j++) {
-					m=rx_pkts[j] ;
-					lp->m_port.dump_packet( m);
-					rte_pktmbuf_free(m);
-				}
-			} /*cnt_p*/
-		}/* for*/
-	}
-}
-
-
-void CLatencyManager::handle_rx_pkt(CLatencyManagerPerPort * lp,
-                                    rte_mbuf_t * m){
-    CRx_check_header *rxc;
-    lp->m_port.check_packet(m,rxc);
-    if ( unlikely(rxc!=NULL) ){
-        m_rx_check_manager.handle_packet(rxc);
-    }
-    rte_pktmbuf_free(m);
-}
-
-void CLatencyManager::handle_latecy_pkt_msg(uint8_t thread_id,
-                                            CGenNodeLatencyPktInfo * msg){
-
-    assert(msg->m_latency_offset==0xdead);
-
-    uint8_t rx_port_index=(thread_id<<1)+(msg->m_dir&1);
-    assert( rx_port_index <m_max_ports ) ;
-    CLatencyManagerPerPort * lp=&m_ports[rx_port_index];
-    handle_rx_pkt(lp,(rte_mbuf_t *)msg->m_pkt);
-}
-
-
-void  CLatencyManager::run_rx_queue_msgs(uint8_t thread_id,
-                                         CNodeRing * r){
-
-    while ( true ) {
-        CGenNode * node;
-        if ( r->Dequeue(node)!=0 ){
-            break;
-        }
-        assert(node);
-
-        CGenNodeMsgBase * msg=(CGenNodeMsgBase *)node;
-
-        uint8_t   msg_type =  msg->m_msg_type;
-        switch (msg_type ) {
-        case CGenNodeMsgBase::LATENCY_PKT:
-            handle_latecy_pkt_msg(thread_id,(CGenNodeLatencyPktInfo *) msg);
-            break;
-        default:
-            printf("ERROR latency-thread message type is not valid %d \n",msg_type);
-            assert(0);
-        }
-
-        CGlobalInfo::free_node(node);
-    }
-}
-
-void  CLatencyManager::try_rx_queues(){
-
-    CMessagingManager * rx_dp = CMsgIns::Ins()->getRxDp();
-    uint8_t threads=CMsgIns::Ins()->get_num_threads();
-    int ti;
-    for (ti=0; ti<(int)threads; ti++) {
-        CNodeRing * r = rx_dp->getRingDpToCp(ti);
-        if ( !r->isEmpty() ){
-            run_rx_queue_msgs((uint8_t)ti,r);
-        }
-    }
-}
-
-
-void  CLatencyManager::try_rx(){
-    rte_mbuf_t * rx_pkts[64];
-    int i;
-    for (i=0; i<m_max_ports; i++) {
-        CLatencyManagerPerPort * lp=&m_ports[i];
-        rte_mbuf_t * m;
-        m_cpu_dp_u.start_work();
-        /* try to read 64 packets clean up the queue */
-        uint16_t cnt_p = lp->m_io->rx_burst(rx_pkts, 64);
-        if (cnt_p) {
-            int j;
-            for (j=0; j<cnt_p; j++) {
-                m=rx_pkts[j] ;
-                handle_rx_pkt(lp,m);
-            }
-            /* commit only if there was work to do ! */
-            m_cpu_dp_u.commit();
-          }/* if work */
-      }// all ports
-}
-
-
-void  CLatencyManager::reset(){
-
-    int i;
-    for (i=0; i<m_max_ports; i++) {
-        CLatencyManagerPerPort * lp=&m_ports[i];
-        lp->m_port.reset();
-    }
-
-}
-
-void  CLatencyManager::start(int iter){
-    m_do_stop =false;
-    m_is_active =false;
-    int cnt=0;
-
-    double n_time;
-    CGenNode * node = new CGenNode();
-    node->m_type = CGenNode::FLOW_SYNC;   /* general stuff */
-    node->m_time = now_sec()+0.007;
-    m_p_queue.push(node);
-
-    node = new CGenNode();
-    node->m_type = CGenNode::FLOW_PKT; /* latency */
-    node->m_time = now_sec(); /* 1/cps rate */
-    m_p_queue.push(node);
-    bool do_try_rx_queue =CGlobalInfo::m_options.preview.get_vm_one_queue_enable()?true:false;
-
-
-    while (  !m_p_queue.empty() ) {
-        node = m_p_queue.top();
-        n_time = node->m_time;
-
-        /* wait for event */
-        while ( true ) {
-            double dt = now_sec() - n_time ;
-            if (dt> (0.0)) {
-                break;
-            }
-            if (do_try_rx_queue){
-                try_rx_queues();
-            }
-            try_rx();
-            rte_pause();
-        }
-
-        switch (node->m_type) {
-        case CGenNode::FLOW_SYNC:
-            if ( CGlobalInfo::is_learn_mode() ) {
-                m_nat_check_manager.handle_aging();
-            }
-
-            m_p_queue.pop();
-            node->m_time += SYNC_TIME_OUT;
-            m_p_queue.push(node);
-
-            break;
-        case CGenNode::FLOW_PKT:
-            m_cpu_dp_u.start_work();
-            send_pkt_all_ports();
-            m_p_queue.pop();
-            node->m_time += m_delta_sec;
-            m_p_queue.push(node);
-            m_cpu_dp_u.commit();
-            break;
-        }
-
-        /* this will be called every sync which is 1msec */
-        if ( m_do_stop ) {
-             break;
-        }
-        if ( iter>0   ){
-            if ( ( cnt>iter) ){
-                printf("stop due iter %d\n",iter);
-                break;
-            }
-        } 
-        cnt++;
-    }
-
-    /* free all nodes in the queue */
-    while (!m_p_queue.empty()) {
-        node = m_p_queue.top();
-        m_p_queue.pop();
-        delete node;
-    }
-
-    printf(" latency daemon has stopped\n");
-    if ( get_is_rx_check_mode() ) {
-        m_rx_check_manager.tw_drain();
-    }
-
-}
-
-void  CLatencyManager::stop(){
-    m_do_stop =true;
-}
-
-bool  CLatencyManager::is_active(){
-    return (m_is_active);
-}
-
-
-double CLatencyManager::get_max_latency(){
-    double l=0.0;
-    int i;
-    for (i=0; i<m_max_ports; i++) {
-        CLatencyManagerPerPort * lp=&m_ports[i];
-        if ( l <lp->m_port.m_hist.get_max_latency() ){
-            l=lp->m_port.m_hist.get_max_latency();
-        }
-    }
-    return (l);
-}
-
-double CLatencyManager::get_avr_latency(){
-    double l=0.0;
-    int i;
-    for (i=0; i<m_max_ports; i++) {
-        CLatencyManagerPerPort * lp=&m_ports[i];
-        if ( l <lp->m_port.m_hist.get_average_latency() ){
-            l=lp->m_port.m_hist.get_average_latency();
-        }
-    }
-    return (l);
-}
-
-uint64_t CLatencyManager::get_total_pkt(){
-    int i;
-    uint64_t t=0;
-    for (i=0; i<m_max_ports; i++) {
-        CLatencyManagerPerPort * lp=&m_ports[i];
-        t+=lp->m_port.m_tx_pkt_ok ;
-    }
-    return  t;
-}
-
-uint64_t CLatencyManager::get_total_bytes(){
-    int i;
-    uint64_t t=0;
-    for (i=0; i<m_max_ports; i++) {
-        CLatencyManagerPerPort * lp=&m_ports[i];
-        t+=lp->m_port.m_tx_pkt_ok* (m_pkt_gen.get_pkt_size()+4);
-    }
-    return  t;
-
-}
-
-
-bool   CLatencyManager::is_any_error(){
-    int i;
-    for (i=0; i<m_max_ports; i++) {
-        CLatencyManagerPerPort * lp=&m_ports[i];
-        if ( lp->m_port.is_any_err() ){
-            return (true);
-        }
-    }
-    return  (false);
-}
-
-
-void CLatencyManager::dump_json(std::string & json ){
-    json="{\"name\":\"trex-latecny\",\"type\":0,\"data\":{";
-    int i;
-    for (i=0; i<m_max_ports; i++) {
-        CLatencyManagerPerPort * lp=&m_ports[i];
-        lp->m_port.dump_json(json);
-    }
-
-    json+="\"unknown\":0}}"  ;
-
-}
-
-void CLatencyManager::dump_json_v2(std::string & json ){
-    json="{\"name\":\"trex-latecny-v2\",\"type\":0,\"data\":{";
-    json+=add_json("cpu_util",m_cpu_cp_u.GetVal());
-
-    int i;
-    for (i=0; i<m_max_ports; i++) {
-        CLatencyManagerPerPort * lp=&m_ports[i];
-        lp->m_port.dump_json_v2(json);
-    }
-
-    json+="\"unknown\":0}}"  ;
-
-}
-
-void CLatencyManager::DumpRxCheck(FILE *fd){
-    if ( get_is_rx_check_mode() ) {
-        fprintf(fd," rx checker : \n");
-        m_rx_check_manager.DumpShort(fd);
-        m_rx_check_manager.Dump(fd);
-    }
-}
-
-void CLatencyManager::DumpShortRxCheck(FILE *fd){
-    if ( get_is_rx_check_mode() ) {
-        m_rx_check_manager.DumpShort(fd);
-    }
-}
-
-void CLatencyManager::rx_check_dump_json(std::string & json){
-    if ( get_is_rx_check_mode() ) {
-        m_rx_check_manager.dump_json(json );
-    }
-}
-
-void CLatencyManager::update(){
-    m_cpu_cp_u.Update() ;
-}
-
-void CLatencyManager::DumpShort(FILE *fd){
-    int i;
-    fprintf(fd," Cpu Utilization : %2.1f %%  \n",m_cpu_cp_u.GetVal());
-    CCPortLatency::DumpShortHeader(fd);
-    for (i=0; i<m_max_ports; i++) {
-        fprintf(fd," %d | ",i);
-        CLatencyManagerPerPort * lp=&m_ports[i];
-        lp->m_port.DumpShort(fd);
-        fprintf(fd,"\n");
-    }
-
-
-}
-
-void CLatencyManager::Dump(FILE *fd){
-    int i;
-    fprintf(fd," cpu : %2.1f  %% \n",m_cpu_cp_u.GetVal());
-    for (i=0; i<m_max_ports; i++) {
-        fprintf(fd," port   %d \n",i);
-        fprintf(fd," -----------------\n");
-        CLatencyManagerPerPort * lp=&m_ports[i];
-        lp->m_port.DumpCounters(fd);
-    }
-}
-
-void CLatencyManager::DumpRxCheckVerification(FILE *fd,
-                                              uint64_t total_tx_rx_check){
-    if ( !get_is_rx_check_mode() ) {
-        fprintf(fd," rx_checker is disabled  \n");
-        return;
-    }
-    fprintf(fd," rx_check Tx : %llu \n", (unsigned long long)total_tx_rx_check);
-    fprintf(fd," rx_check Rx : %llu \n", (unsigned long long)m_rx_check_manager.getTotalRx() );
-    fprintf(fd," rx_check verification :" );
-    if (m_rx_check_manager.getTotalRx() == total_tx_rx_check) {
-        fprintf(fd," OK \n" );
-    }else{
-        fprintf(fd," FAIL \n" );
-    }
-}
-
-
-
 void CTcpSeq::update(uint8_t *p, CFlowPktInfo *pkt_info, int16_t s_size){
     TCPHeader *tcp= (TCPHeader *)(p+pkt_info->m_pkt_indication.getFastTcpOffset());
     uint32_t seqnum, acknum;
@@ -6865,12 +5984,14 @@ bool CSimplePacketParser::Parse(){
     case EthernetHeader::Protocol::IP :
         // IPv4 packet
         ipv4=(IPHeader *)(p+14);
+        m_l4 = (uint8_t *)ipv4 + ipv4->getHeaderLength();
         protocol = ipv4->getProtocol();
         m_option_offset = 14 + IPV4_HDR_LEN;
         break;
     case EthernetHeader::Protocol::IPv6 :
         // IPv6 packet
         ipv6=(IPv6Header *)(p+14);
+        m_l4 = (uint8_t *)ipv6 + ipv6->getHeaderLength();
         protocol = ipv6->getNextHdr();
         m_option_offset = 14 +IPV6_HDR_LEN;
         break;
@@ -6880,12 +6001,14 @@ bool CSimplePacketParser::Parse(){
         case EthernetHeader::Protocol::IP:
             // IPv4 packet
             ipv4=(IPHeader *)(p+18);
+            m_l4 = (uint8_t *)ipv4 + ipv4->getHeaderLength();
             protocol = ipv4->getProtocol();
             m_option_offset = 18+ IPV4_HDR_LEN;
             break;
         case EthernetHeader::Protocol::IPv6 :
             // IPv6 packet
             ipv6=(IPv6Header *)(p+18);
+            m_l4 = (uint8_t *)ipv6 + ipv6->getHeaderLength();
             protocol = ipv6->getNextHdr();
             m_option_offset = 18 + IPV6_HDR_LEN;
             break;
@@ -6929,7 +6052,3 @@ void CGenNodeBase::free_base(){
 
 }
 
-
-
-
-
diff --git a/src/bp_sim.h b/src/bp_sim.h
index 0da7fb99..da8e8780 100755
--- a/src/bp_sim.h
+++ b/src/bp_sim.h
@@ -37,6 +37,7 @@ limitations under the License.
 #include <string>
 #include <common/Network/Packet/TcpHeader.h>
 #include <common/Network/Packet/UdpHeader.h>
+#include <common/Network/Packet/IcmpHeader.h>
 #include <common/Network/Packet/IPHeader.h>
 #include <common/Network/Packet/IPv6Header.h>
 #include <common/Network/Packet/EthernetHeader.h>
@@ -380,7 +381,7 @@ public:
      * 
      * @return 
      */
-    virtual int update_mac_addr_from_global_cfg(pkt_dir_t       dir, rte_mbuf_t      *m)=0;
+    virtual int update_mac_addr_from_global_cfg(pkt_dir_t       dir, uint8_t * p)=0;
 
     /**
      * translate a port_id to the correct dir on the core
@@ -749,6 +750,7 @@ public:
         prefix="";
         m_mac_splitter=0;
         m_run_mode = RUN_MODE_INVALID;
+        m_l_pkt_mode = 0;
     }
 
 
@@ -771,7 +773,7 @@ public:
     uint16_t        m_io_mode; //0,1,2 0 disable, 1- normal , 2 - short 
     uint16_t        m_run_flags;
     uint8_t         m_mac_splitter;
-    uint8_t         m_pad;
+    uint8_t         m_l_pkt_mode;
     trex_run_mode_e    m_run_mode;
 
 
@@ -828,6 +830,9 @@ public:
         return (  (m_run_flags &RUN_FLAGS_RXCHECK_CONST_TS)?true:false );
     }
 
+    inline uint8_t get_l_pkt_mode(){
+        return (m_l_pkt_mode);
+    }
     void dump(FILE *fd);
 };
 
@@ -1237,7 +1242,8 @@ static inline int get_is_rx_check_mode(){
 }
 
 static inline bool get_is_rx_filter_enable(){
-    return ( ( get_is_rx_check_mode() || CGlobalInfo::is_learn_mode()) ?true:false );
+    uint32_t latency_rate=CGlobalInfo::m_options.m_latency_rate;
+    return ( ( get_is_rx_check_mode() || CGlobalInfo::is_learn_mode() || latency_rate != 0) ?true:false );
 }
 static inline uint16_t get_rx_check_hops() {
     return (CGlobalInfo::m_options.m_rx_check_hops);
@@ -1799,7 +1805,7 @@ public:
     virtual int write_pkt(CCapPktRaw *pkt_raw);
     virtual int close_file(void);
 
-    virtual int update_mac_addr_from_global_cfg(pkt_dir_t       dir, rte_mbuf_t      *m){
+    virtual int update_mac_addr_from_global_cfg(pkt_dir_t       dir, uint8_t * p){
         return (0);
     }
 
@@ -1878,7 +1884,7 @@ public:
         return (0);
     }
 
-    virtual int update_mac_addr_from_global_cfg(pkt_dir_t       dir, rte_mbuf_t      *m){
+    virtual int update_mac_addr_from_global_cfg(pkt_dir_t       dir, uint8_t * p){
         return (0);
     }
 
@@ -2061,11 +2067,8 @@ inline bool CFlowKey::operator ==(const CFlowKey& rhs) const{
 #define IS_VALID_S 1
 #define IS_VALID_E 1
 
-#define IS_TCP_S 2
-#define IS_TCP_E 2
-
-#define IS_UDP_S 3
-#define IS_UDP_E 3
+#define PROTO_S 3
+#define PROTO_E 2
 
 #define IS_INIT_SIDE 4
 
@@ -2235,19 +2238,27 @@ public:
     }
 
     inline void SetIsTcp(bool is_valid){
-        btSetMaskBit32(m_flags,IS_TCP_S,IS_TCP_E,is_valid?1:0);
+        btSetMaskBit32(m_flags,PROTO_S,PROTO_E,is_valid?1:0);
     }
 
     inline bool IsTcp(){
-        return (btGetMaskBit32(m_flags,IS_TCP_S,IS_TCP_E) ? true:false);
+        return ((btGetMaskBit32(m_flags,PROTO_S,PROTO_E) == 1) ? true:false);
     }
 
     inline void SetIsUdp(bool is_valid){
-        btSetMaskBit32(m_flags,IS_UDP_S,IS_UDP_E,is_valid?1:0);
+        btSetMaskBit32(m_flags,PROTO_S,PROTO_E,is_valid?2:0);
     }
 
     inline bool IsUdp(){
-        return (btGetMaskBit32(m_flags,IS_UDP_S,IS_UDP_E) ? true:false);
+        return ((btGetMaskBit32(m_flags,PROTO_S,PROTO_E) == 2) ? true:false);
+    }
+
+    inline void SetIsIcmp(bool is_valid){
+        btSetMaskBit32(m_flags,PROTO_S,PROTO_E,is_valid?3:0);
+    }
+
+    inline bool IsIcmp(){
+        return ((btGetMaskBit32(m_flags,PROTO_S,PROTO_E) == 3) ? true:false);
     }
 
     inline void SetId(uint16_t _id){
@@ -2379,6 +2390,7 @@ public:
     union {                             
         TCPHeader * m_tcp;
         UDPHeader * m_udp;
+        ICMPHeader * m_icmp;      
     } l4;
     uint8_t *       m_payload;
     uint16_t        m_payload_len;
@@ -2902,7 +2914,11 @@ inline void CFlowPktInfo::update_pkt_info(char *p,
                 m_udp->setDestPort(src_port);
             }
         }else{
-            BP_ASSERT(0);
+#ifdef _DEBUG
+            if (!m_pkt_indication.m_desc.IsIcmp()) {
+               BP_ASSERT(0);
+            }
+#endif
         }
     }
 }
@@ -3733,312 +3749,6 @@ inline void CFlowGeneratorRecPerThread::generate_flow(CNodeGenerator * gen,
                                node);
 }
 
-
-
-class CLatencyPktInfo {
-public:
-    void Create();
-    void Delete();
-    void set_ip(uint32_t src,
-                uint32_t dst,
-                uint32_t dual_port_mask);
-    rte_mbuf_t * generate_pkt(int port_id,uint32_t extern_ip=0);
-
-    CGenNode   *    getNode(){
-        return (&m_dummy_node);
-    }
-
-    uint16_t get_payload_offset(void){
-        return ( m_pkt_indication.getFastPayloadOffset());
-    }
-
-    uint16_t get_pkt_size(void){
-        return ( m_packet->pkt_len );
-    }
-
-private:
-    ipaddr_t            m_client_ip;
-    ipaddr_t            m_server_ip;
-    uint32_t            m_dual_port_mask;
-
-    CGenNode            m_dummy_node;
-    CFlowPktInfo        m_pkt_info;
-    CPacketIndication   m_pkt_indication;
-    CCapPktRaw *        m_packet;
-};
-
-
-#define LATENCY_MAGIC 0x12345600
-
-struct  latency_header {
-
-    uint64_t time_stamp;
-    uint32_t magic;
-    uint32_t seq;
-
-    uint8_t get_id(){
-        return( magic & 0xff);
-    }
-};
-
-
-class CSimplePacketParser {
-public:
-
-    CSimplePacketParser(rte_mbuf_t * m){
-        m_m=m;
-    }
-
-    bool Parse();
-    uint8_t getTTl();
-    uint16_t getPktSize();
-
-
-
-    inline bool IsLatencyPkt(){
-        return ( (m_protocol ==0x84 )?true:false );
-    }
-
-
-public:
-    IPHeader *      m_ipv4;
-    IPv6Header *    m_ipv6;
-    uint8_t         m_protocol;
-    uint16_t        m_vlan_offset;
-    uint16_t        m_option_offset;
-private: 
-    rte_mbuf_t *    m_m ;
-};
-
-
-
-class CLatencyManager ;
-// per port 
-class CCPortLatency {
-public:
-    bool Create(CLatencyManager * parent,
-                uint8_t id,
-                uint16_t offset,
-                uint16_t pkt_size,
-                CCPortLatency * rx_port
-                );
-    void Delete();
-    void reset();
-    bool can_send_packet(){
-        if ( !CGlobalInfo::is_learn_mode() ) {
-            return(true);
-        }
-        return ( m_nat_can_send );
-    }
-    uint32_t external_nat_ip(){
-        return (m_nat_external_ip);
-    }
-
-    void update_packet(rte_mbuf_t * m);
-
-    bool do_learn(uint32_t external_ip);
-
-    bool check_packet(rte_mbuf_t * m,
-                      CRx_check_header * & rx_p);
-    bool check_rx_check(rte_mbuf_t * m);
-
-
-	bool dump_packet(rte_mbuf_t * m);
-
-    void DumpCounters(FILE *fd);
-    void dump_counters_json(std::string & json );
-
-    void DumpShort(FILE *fd);
-    void dump_json(std::string & json );
-    void dump_json_v2(std::string & json );
-
-    uint32_t get_jitter_usec(void){
-        return ((uint32_t)(m_jitter.get_jitter()*1000000.0));
-    }
-
-
-    static void DumpShortHeader(FILE *fd);
-
-    bool is_any_err(){
-        if (  (m_tx_pkt_ok == m_rx_port->m_pkt_ok ) && 
-
-              ((m_unsup_prot+
-                m_no_magic+
-                m_no_id+
-                m_seq_error+
-                m_length_error+m_no_ipv4_option+m_tx_pkt_err)==0) ) {
-            return (false);
-        }
-        return (true);
-    }
-
-private:
-    std::string get_field(std::string name,float f);
-
-    
-
-private:
-     CLatencyManager * m_parent;
-     CCPortLatency *   m_rx_port; /* corespond rx port  */
-     bool              m_nat_learn;  
-     bool              m_nat_can_send;
-     uint32_t          m_nat_external_ip;
-
-     uint32_t m_tx_seq;
-     uint32_t m_rx_seq;
-
-     uint8_t  m_pad;
-     uint8_t  m_id;
-     uint16_t m_offset;
-
-     uint16_t m_pkt_size;
-     uint16_t pad1[3];
-
-public:
-     uint64_t m_tx_pkt_ok;
-     uint64_t m_tx_pkt_err;
-
-     uint64_t m_pkt_ok;
-     uint64_t m_unsup_prot;
-     uint64_t m_no_magic;
-     uint64_t m_no_id;
-     uint64_t m_seq_error;
-     uint64_t m_rx_check;
-     uint64_t m_no_ipv4_option;
-
-
-     uint64_t m_length_error;
-     CTimeHistogram  m_hist; /* all window */
-     CJitter         m_jitter; 
-};
-
-
-class CPortLatencyHWBase {
-public:
-    virtual int tx(rte_mbuf_t * m)=0;
-    virtual rte_mbuf_t * rx()=0;
-    virtual uint16_t rx_burst(struct rte_mbuf **rx_pkts, 
-                               uint16_t nb_pkts){
-        return(0);
-    }
-};
-
-
-class CLatencyManagerCfg {
-public:
-    CLatencyManagerCfg (){
-        m_max_ports=0;
-        m_cps=0.0;
-        m_client_ip.v4=0x10000000;
-        m_server_ip.v4=0x20000000;
-        m_dual_port_mask=0x01000000;
-    }
-    uint32_t             m_max_ports;
-    double               m_cps;// CPS
-    CPortLatencyHWBase * m_ports[MAX_LATENCY_PORTS];
-    ipaddr_t             m_client_ip;
-    ipaddr_t             m_server_ip;
-    uint32_t             m_dual_port_mask;
-
-};
-
-
-
-class CLatencyManagerPerPort {
-public:
-     CCPortLatency          m_port;
-     CPortLatencyHWBase  *  m_io;
-     uint32_t               m_flag;
-
-};
-
-
-class CLatencyManager {
-public:
-    bool Create(CLatencyManagerCfg * cfg);
-    void Delete();
-
-public:
-    void  reset();
-    void  start(int iter);
-    void  stop();
-    bool  is_active();
-
-    void set_ip(uint32_t client_ip,
-                uint32_t server_ip,
-                uint32_t mask_dual_port){
-        m_pkt_gen.set_ip(client_ip,server_ip,mask_dual_port);
-    }
-
-public:
-    void Dump(FILE *fd); // dump all
-    void DumpShort(FILE *fd); // dump short histogram of latency 
-
-    void DumpRxCheck(FILE *fd); // dump all
-    void DumpShortRxCheck(FILE *fd); // dump short histogram of latency 
-    void rx_check_dump_json(std::string & json);
-    uint16_t get_latency_header_offset(){
-        return ( m_pkt_gen.get_payload_offset() );
-    }
-    void update();
-    void dump_json(std::string & json ); // dump to json 
-    void dump_json_v2(std::string & json );
-
-
-
-    void DumpRxCheckVerification(FILE *fd,uint64_t total_tx_rx_check);
-    void set_mask(uint32_t mask){
-        m_port_mask=mask;
-    }
-
-    double get_max_latency(void);
-    double get_avr_latency(void);
-    bool   is_any_error();
-    uint64_t get_total_pkt();
-    uint64_t get_total_bytes();
-    CNatRxManager * get_nat_manager(){
-        return ( &m_nat_check_manager );
-    }
-
-private:
-    void  send_pkt_all_ports();
-    void  try_rx();
-    void  try_rx_queues();
-    void  run_rx_queue_msgs(uint8_t thread_id,
-                                             CNodeRing * r);
-	void  wait_for_rx_dump();
-    void  handle_rx_pkt(CLatencyManagerPerPort * lp,
-                        rte_mbuf_t * m);
-
-
-private:
-    /* messages handlers */
-    void handle_latecy_pkt_msg(uint8_t thread_id,
-                               CGenNodeLatencyPktInfo * msg);
-
-
-
-private:
-     pqueue_t                m_p_queue; /* priorty queue */
-     bool                    m_is_active;
-     CLatencyPktInfo         m_pkt_gen;
-     CLatencyManagerPerPort  m_ports[MAX_LATENCY_PORTS];
-     uint64_t                m_d_time; // calc tick betwen sending 
-     double                  m_cps;
-     double                  m_delta_sec;
-     uint64_t                m_start_time; // calc tick betwen sending 
-     uint32_t                m_port_mask;
-     uint32_t                m_max_ports;
-	 RxCheckManager 		 m_rx_check_manager;
-     CNatRxManager           m_nat_check_manager;
-     CCpuUtlDp               m_cpu_dp_u;
-     CCpuUtlCp               m_cpu_cp_u;
-
-     volatile bool           m_do_stop __rte_cache_aligned ;
-
-};
-
-
 inline bool CGenNode::is_responder_pkt(){
     return ( m_pkt_info->m_pkt_indication.m_desc.IsInitSide() ?false:true );
 }
diff --git a/src/common/Network/Packet/IcmpHeader.h b/src/common/Network/Packet/IcmpHeader.h
new file mode 100644
index 00000000..99d89329
--- /dev/null
+++ b/src/common/Network/Packet/IcmpHeader.h
@@ -0,0 +1,89 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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.
+*/
+
+#ifndef _ICMP_HEADER_H_
+#define _ICMP_HEADER_H_
+
+#include "PacketHeaderBase.h"
+#include "IPHeader.h"
+
+class ICMPHeader
+{
+
+public:
+    ICMPHeader()
+	{
+		setCode(0);
+		setType(0);
+		setSeqNum(0xDEAD);
+		setId(0xBEEF);
+		setChecksum(0);
+	}
+
+    ICMPHeader(uint8_t  argType,
+	       uint8_t  argCode,
+	       uint16_t argId,
+	       uint16_t argSeqNum)
+	{
+		setType(argType);
+		setCode(argCode);
+		setId(argId);
+		setSeqNum(argSeqNum);
+	}
+
+
+    inline  void setCode(uint8_t data);
+    inline  uint8_t getCode();
+
+    inline  void setType(uint8_t data);
+    inline  uint8_t getType();
+
+    inline  void setSeqNum(uint16_t data);
+    inline  uint16_t getSeqNum();
+
+    inline  void setId(uint16_t data);
+    inline  uint16_t getId();
+
+    inline  void setChecksum(uint16_t data);
+    inline  uint16_t getChecksum();
+
+    inline void updateCheckSum(uint16_t len);
+    inline bool isCheckSumOk(uint16_t len);
+    inline uint16_t calcCheckSum(uint16_t len);
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Common Header Interface
+////////////////////////////////////////////////////////////////////////////////////////
+
+public: 
+    inline	uint8_t*  getPointer          (){return (uint8_t*)this;}
+    inline	uint32_t  getSize             (){return 8;}
+
+    void    dump                (FILE*  fd);
+
+private:
+    uint8_t   myType;
+    uint8_t   myCode;
+    uint16_t  myChecksum;
+    uint16_t  myId;
+    uint16_t  mySeqNum;
+};
+
+
+#include "IcmpHeader.inl"
+
+#endif 
diff --git a/src/common/Network/Packet/IcmpHeader.inl b/src/common/Network/Packet/IcmpHeader.inl
new file mode 100644
index 00000000..0e6806f8
--- /dev/null
+++ b/src/common/Network/Packet/IcmpHeader.inl
@@ -0,0 +1,87 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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.
+*/
+
+inline void ICMPHeader::setCode(uint8_t argCode)
+{
+    myCode = argCode;
+}
+
+inline uint8_t ICMPHeader::getCode()
+{
+    return myCode;
+}
+
+inline void   ICMPHeader::setType(uint8_t argType)
+{
+    myType = argType;
+}
+
+inline uint8_t ICMPHeader::getType()
+{
+    return myType;
+}
+
+inline void    ICMPHeader::setSeqNum(uint16_t argSeqNum)
+{
+    mySeqNum = PKT_NTOHS(argSeqNum);
+}
+
+inline uint16_t ICMPHeader::getSeqNum()
+{
+    return PKT_NTOHS(mySeqNum);
+}
+
+inline void    ICMPHeader::setId(uint16_t argId)
+{
+    myId = PKT_NTOHS(argId);
+}
+
+inline uint16_t ICMPHeader::getId()
+{
+    return PKT_NTOHS(myId);
+}
+
+inline void ICMPHeader::setChecksum(uint16_t argNewChecksum)
+{
+    myChecksum = PKT_NTOHS(argNewChecksum);
+}
+
+inline uint16_t ICMPHeader::getChecksum()
+{
+    return PKT_NTOHS(myChecksum);
+}
+
+inline void ICMPHeader::updateCheckSum(uint16_t len)
+{
+	setChecksum(0);// must be here 
+
+	myChecksum =calcCheckSum(len);
+}
+
+inline bool ICMPHeader::isCheckSumOk(uint16_t len)
+{
+	uint16_t theChecksum= PKT_NTOHS(calcCheckSum(len));
+
+	return(theChecksum == 0);
+}
+
+// len is in bytes. Including ICMP header + data.
+inline uint16_t ICMPHeader::calcCheckSum(uint16_t len)
+{
+	uint16_t theChecksum = pkt_InetChecksum((uint8_t*)this, len);
+
+	return(theChecksum);
+}
diff --git a/src/common/bitMan.h b/src/common/bitMan.h
index ffa05598..8019b3f7 100755
--- a/src/common/bitMan.h
+++ b/src/common/bitMan.h
@@ -160,8 +160,8 @@ inline void btSetMaskBit32(unsigned int & a,
      btSetMaskBit<unsigned int>(a,startbit,stopbit,newVal);
 }
 
-/* start > stop             startbit = 10 , 
-                            stop    = 8 
+/* Notice: 
+   startbit should be bigger (or equal) than stopbit
 
 count like big E
 
diff --git a/src/dpdk_lib18/librte_ether/rte_eth_ctrl.h b/src/dpdk_lib18/librte_ether/rte_eth_ctrl.h
index 642adb76..d9cdb379 100755
--- a/src/dpdk_lib18/librte_ether/rte_eth_ctrl.h
+++ b/src/dpdk_lib18/librte_ether/rte_eth_ctrl.h
@@ -202,6 +202,7 @@ enum rte_eth_flow_type {
 struct rte_eth_ipv4_flow {
 	uint32_t src_ip;      /**< IPv4 source address to match. */
 	uint32_t dst_ip;      /**< IPv4 destination address to match. */
+	uint8_t l4_proto;     /* IPv4 protocol to match */
 };
 
 /**
diff --git a/src/dpdk_lib18/librte_pmd_i40e/i40e_ethdev.c b/src/dpdk_lib18/librte_pmd_i40e/i40e_ethdev.c
index 9c0db84c..b0e00464 100755
--- a/src/dpdk_lib18/librte_pmd_i40e/i40e_ethdev.c
+++ b/src/dpdk_lib18/librte_pmd_i40e/i40e_ethdev.c
@@ -355,6 +355,20 @@ static inline void i40e_flex_payload_reg_init(struct i40e_hw *hw)
 #define I40E_PRTQF_FD_INSET(_i, _j)    (0x00250000 + ((_i) * 64 + (_j) * 32))
 #define I40E_GLQF_FD_MSK(_i, _j)       (0x00267200 + ((_i) * 4 + (_j) * 8))
 
+void dump_regs(struct i40e_hw *hw)
+{
+    int reg_nums[] = {31, 33, 34, 35, 41, 43};
+    int i;
+    uint32_t reg;
+
+    for (i =0; i < sizeof (reg_nums)/sizeof(int); i++) {
+	reg = I40E_READ_REG(hw,I40E_PRTQF_FD_INSET(reg_nums[i], 0));
+        printf("I40E_PRTQF_FD_INSET(%d, 0): 0x%08x\n", reg_nums[i], reg);
+	reg = I40E_READ_REG(hw,I40E_PRTQF_FD_INSET(reg_nums[i], 1));
+        printf("I40E_PRTQF_FD_INSET(%d, 1): 0x%08x\n", reg_nums[i], reg);
+    }
+}
+
 static inline void i40e_fillter_fields_reg_init(struct i40e_hw *hw)
 {
 	uint32_t reg;
@@ -403,6 +417,10 @@ static inline void i40e_fillter_fields_reg_init(struct i40e_hw *hw)
 	//printf("I40E_PRTQF_FD_INSET(34, 1) = 0x%08x\n", reg);
 	I40E_WRITE_REG(hw, I40E_PRTQF_FD_INSET(34, 1), 0x00040000);
 
+        // filter IP according to ttl and L4 protocol
+	I40E_WRITE_REG(hw, I40E_PRTQF_FD_INSET(35, 0), 0);
+	I40E_WRITE_REG(hw, I40E_PRTQF_FD_INSET(35, 1), 0x00040000);
+
 	reg = I40E_READ_REG(hw,I40E_PRTQF_FD_INSET(44, 0));
 	//printf("I40E_PRTQF_FD_INSET(44, 0) = 0x%08x\n", reg);
 	I40E_WRITE_REG(hw, I40E_PRTQF_FD_INSET(44, 0), 0);
@@ -420,8 +438,6 @@ static inline void i40e_fillter_fields_reg_init(struct i40e_hw *hw)
 	I40E_WRITE_FLUSH(hw);
 }
 
-
-
 static int
 eth_i40e_dev_init(__rte_unused struct eth_driver *eth_drv,
                   struct rte_eth_dev *dev)
diff --git a/src/dpdk_lib18/librte_pmd_i40e/i40e_fdir.c b/src/dpdk_lib18/librte_pmd_i40e/i40e_fdir.c
index 98df9357..4b209e18 100755
--- a/src/dpdk_lib18/librte_pmd_i40e/i40e_fdir.c
+++ b/src/dpdk_lib18/librte_pmd_i40e/i40e_fdir.c
@@ -727,7 +727,10 @@ i40e_fdir_fill_eth_ip_head(const struct rte_eth_fdir_input *fdir_input,
 		 */
 		ip->src_addr = fdir_input->flow.ip4_flow.dst_ip;
 		ip->dst_addr = fdir_input->flow.ip4_flow.src_ip;
-		ip->next_proto_id = next_proto[fdir_input->flow_type];
+                if (fdir_input->flow_type == RTE_ETH_FLOW_TYPE_IPV4_OTHER) {
+                    ip->next_proto_id = fdir_input->flow.ip4_flow.l4_proto;
+                } else
+                    ip->next_proto_id = next_proto[fdir_input->flow_type];
 		break;
 	case RTE_ETH_FLOW_TYPE_UDPV6:
 	case RTE_ETH_FLOW_TYPE_TCPV6:
diff --git a/src/gtest/trex_stateless_gtest.cpp b/src/gtest/trex_stateless_gtest.cpp
index 5b298023..1626ac25 100644
--- a/src/gtest/trex_stateless_gtest.cpp
+++ b/src/gtest/trex_stateless_gtest.cpp
@@ -30,7 +30,896 @@ limitations under the License.
 #include <trex_stateless_port.h>
 #include <trex_rpc_server_api.h>
 #include <iostream>
+#include <vector>
 
+
+
+
+class CPcapLoader {
+public:
+    CPcapLoader();
+    ~CPcapLoader();
+
+
+public:
+    bool load_pcap_file(std::string file,int pkt_id=0);
+    void update_ip_src(uint32_t ip_addr);
+    void clone_packet_into_stream(TrexStream * stream);
+    void dump_packet();
+
+public:
+    bool                    m_valid;
+    CCapPktRaw              m_raw;
+    CPacketIndication       m_pkt_indication;
+};
+
+CPcapLoader::~CPcapLoader(){
+}
+
+bool CPcapLoader::load_pcap_file(std::string cap_file,int pkt_id){
+    m_valid=false;
+    CPacketParser parser;
+
+    CCapReaderBase * lp=CCapReaderFactory::CreateReader((char *)cap_file.c_str(),0);
+
+    if (lp == 0) {
+        printf(" ERROR file %s does not exist or not supported \n",(char *)cap_file.c_str());
+        return false;
+    }
+
+    int cnt=0;
+    bool found =false;
+
+
+    while ( true ) {
+        /* read packet */
+        if ( lp->ReadPacket(&m_raw) ==false ){
+            break;
+        }
+        if (cnt==pkt_id) {
+            found = true;
+            break;
+        }
+        cnt++;
+    }
+    if ( found ){
+        if ( parser.ProcessPacket(&m_pkt_indication, &m_raw) ){
+            m_valid = true;
+        }
+    }
+
+    delete lp;
+    return (m_valid);
+}
+
+void CPcapLoader::update_ip_src(uint32_t ip_addr){
+
+    if ( m_pkt_indication.l3.m_ipv4 ) {
+        m_pkt_indication.l3.m_ipv4->setSourceIp(ip_addr);
+        m_pkt_indication.l3.m_ipv4->updateCheckSum();
+    }
+}           
+
+void CPcapLoader::clone_packet_into_stream(TrexStream * stream){
+
+    uint16_t pkt_size=m_raw.getTotalLen();
+
+    uint8_t      *binary = new uint8_t[pkt_size];
+    memcpy(binary,m_raw.raw,pkt_size);
+    stream->m_pkt.binary = binary;
+    stream->m_pkt.len    = pkt_size;
+}
+
+
+
+
+CPcapLoader::CPcapLoader(){
+
+}
+
+void CPcapLoader::dump_packet(){
+    if (m_valid ) {
+        m_pkt_indication.Dump(stdout,1);
+    }else{
+        fprintf(stdout," no packets were found \n");
+    }
+}
+
+
+
+
+class basic_vm  : public testing::Test {
+    protected:
+     virtual void SetUp() {
+     }
+     virtual void TearDown() {
+     }
+   public:
+};
+
+
+
+
+TEST_F(basic_vm, pkt_size) {
+
+    EXPECT_EQ(calc_writable_mbuf_size(36,62),62);
+    EXPECT_EQ(calc_writable_mbuf_size(63,62),62);
+    EXPECT_EQ(calc_writable_mbuf_size(45,65),65);
+    EXPECT_EQ(calc_writable_mbuf_size(66,65),65);
+    EXPECT_EQ(calc_writable_mbuf_size(62,128),128);
+    EXPECT_EQ(calc_writable_mbuf_size(62,252),61);
+    EXPECT_EQ(calc_writable_mbuf_size(121,252),120);
+    EXPECT_EQ(calc_writable_mbuf_size(253,252),252);
+    EXPECT_EQ(calc_writable_mbuf_size(250,252),252);
+    EXPECT_EQ(calc_writable_mbuf_size(184,252),183);
+}
+
+
+/* start/stop/stop back to back */
+TEST_F(basic_vm, vm0) {
+
+    StreamVm vm;
+
+    vm.add_instruction( new StreamVmInstructionFixChecksumIpv4(20) );
+    vm.add_instruction( new StreamVmInstructionFlowMan( "var1",1,
+                                                        StreamVmInstructionFlowMan::FLOW_VAR_OP_INC,0,1,7 ) 
+                        );
+    vm.add_instruction( new StreamVmInstructionWriteToPkt( "var1",14, 0,true)
+                        );
+
+    vm.Dump(stdout);
+}
+
+TEST_F(basic_vm, vm1) {
+
+    StreamVm vm;
+
+    vm.add_instruction( new StreamVmInstructionFlowMan( "var1",1,
+                                                        StreamVmInstructionFlowMan::FLOW_VAR_OP_INC,0,1,7 ) 
+                        );
+    vm.add_instruction( new StreamVmInstructionWriteToPkt( "var1",26, 0,true)
+                        );
+    vm.add_instruction( new StreamVmInstructionFixChecksumIpv4(14) );
+
+    vm.set_packet_size(128);
+
+    vm.compile();
+
+
+    uint32_t program_size=vm.get_dp_instruction_buffer()->get_program_size();
+
+    printf (" program size : %lu \n",(ulong)program_size);
+
+
+    vm.Dump(stdout);
+
+}
+
+TEST_F(basic_vm, vm2) {
+
+    StreamVm vm;
+
+    vm.add_instruction( new StreamVmInstructionFlowMan( "var1",1,
+                                                        StreamVmInstructionFlowMan::FLOW_VAR_OP_INC,4,1,7 ) 
+                        );
+    vm.add_instruction( new StreamVmInstructionWriteToPkt( "var1",26, 0,true)
+                        );
+    //vm.add_instruction( new StreamVmInstructionFixChecksumIpv4(14) );
+
+    vm.set_packet_size(128);
+
+    vm.compile();
+
+
+    uint32_t program_size=vm.get_dp_instruction_buffer()->get_program_size();
+
+    printf (" program size : %lu \n",(ulong)program_size);
+
+
+    vm.Dump(stdout);
+
+    uint8_t test_udp_pkt[14+20+4+4]={ 
+        0x00,0x00,0x00,0x01,0x00,0x00,
+        0x00,0x00,0x00,0x01,0x00,0x00,
+        0x08,0x00,
+
+        0x45,0x00,0x00,0x81, /*14 */
+        0xaf,0x7e,0x00,0x00, /*18 */
+        0x12,0x11,0xd9,0x23, /*22 */
+        0x01,0x01,0x01,0x01, /*26 */
+        0x3d,0xad,0x72,0x1b, /*30 */
+
+        0x11,0x11,
+        0x11,0x11,
+
+        0x00,0x6d,
+        0x00,0x00,
+    };
+
+
+
+    StreamDPVmInstructionsRunner runner;
+
+    uint8_t ex[]={5, 
+                 6, 
+                 7, 
+                 1, 
+                 2, 
+                 3, 
+                 4, 
+                 5, 
+                 6, 
+                 7, 
+                 1, 
+                 2, 
+                 3, 
+                 4, 
+                 5, 
+                 6, 
+                 7, 
+                 1, 
+                 2, 
+                 3}; 
+
+    int i;
+    for (i=0; i<20; i++) {
+        runner.run(program_size, 
+                   vm.get_dp_instruction_buffer()->get_program(),
+                   vm.get_bss_ptr(),
+                   test_udp_pkt);
+        EXPECT_EQ(test_udp_pkt[26],ex[i]);
+    }
+
+}
+
+
+TEST_F(basic_vm, vm3) {
+
+    StreamVm vm;
+
+    vm.add_instruction( new StreamVmInstructionFlowMan( "var1",4 /* size */,
+                                                        StreamVmInstructionFlowMan::FLOW_VAR_OP_INC,4,1,7 ) 
+                        );
+    vm.add_instruction( new StreamVmInstructionWriteToPkt( "var1",26, 0,true)
+                        );
+    //vm.add_instruction( new StreamVmInstructionFixChecksumIpv4(14) );
+
+    vm.set_packet_size(128);
+
+    vm.compile();
+
+
+    uint32_t program_size=vm.get_dp_instruction_buffer()->get_program_size();
+
+    printf (" program size : %lu \n",(ulong)program_size);
+
+
+    vm.Dump(stdout);
+
+    #define PKT_TEST_SIZE (14+20+4+4)
+    uint8_t test_udp_pkt[PKT_TEST_SIZE]={ 
+        0x00,0x00,0x00,0x01,0x00,0x00,
+        0x00,0x00,0x00,0x01,0x00,0x00,
+        0x08,0x00,
+
+        0x45,0x00,0x00,0x81, /*14 */
+        0xaf,0x7e,0x00,0x00, /*18 */
+        0x12,0x11,0xd9,0x23, /*22 */
+        0x01,0x01,0x01,0x01, /*26 */
+        0x3d,0xad,0x72,0x1b, /*30 */
+
+        0x11,0x11,
+        0x11,0x11,
+
+        0x00,0x6d,
+        0x00,0x00,
+    };
+
+
+
+    StreamDPVmInstructionsRunner runner;
+
+    uint8_t ex[]={5, 
+                 6, 
+                 7, 
+                 1, 
+                 2, 
+                 3, 
+                 4, 
+                 5, 
+                 6, 
+                 7, 
+                 1, 
+                 2, 
+                 3, 
+                 4, 
+                 5, 
+                 6, 
+                 7, 
+                 1, 
+                 2, 
+                 3}; 
+
+    int i;
+    for (i=0; i<20; i++) {
+        runner.run(program_size, 
+                   vm.get_dp_instruction_buffer()->get_program(),
+                   vm.get_bss_ptr(),
+                   test_udp_pkt);
+
+        fprintf(stdout," %d \n",i);
+        //utl_DumpBuffer(stdout,test_udp_pkt,PKT_TEST_SIZE,0);
+        /* big */
+        EXPECT_EQ(test_udp_pkt[29],ex[i]);
+        EXPECT_EQ(test_udp_pkt[28],0);
+        EXPECT_EQ(test_udp_pkt[27],0);
+        EXPECT_EQ(test_udp_pkt[26],0);
+    }
+
+}
+
+TEST_F(basic_vm, vm4) {
+
+    StreamVm vm;
+
+    vm.add_instruction( new StreamVmInstructionFlowMan( "var1",4 /* size */,
+                                                        StreamVmInstructionFlowMan::FLOW_VAR_OP_INC,4,1,7 ) 
+                        );
+    vm.add_instruction( new StreamVmInstructionWriteToPkt( "var1",26, 0,false)
+                        );
+    //vm.add_instruction( new StreamVmInstructionFixChecksumIpv4(14) );
+
+    vm.set_packet_size(128);
+
+    vm.compile();
+
+
+    uint32_t program_size=vm.get_dp_instruction_buffer()->get_program_size();
+
+    printf (" program size : %lu \n",(ulong)program_size);
+
+
+    vm.Dump(stdout);
+
+    #define PKT_TEST_SIZE (14+20+4+4)
+    uint8_t test_udp_pkt[PKT_TEST_SIZE]={ 
+        0x00,0x00,0x00,0x01,0x00,0x00,
+        0x00,0x00,0x00,0x01,0x00,0x00,
+        0x08,0x00,
+
+        0x45,0x00,0x00,0x81, /*14 */
+        0xaf,0x7e,0x00,0x00, /*18 */
+        0x12,0x11,0xd9,0x23, /*22 */
+        0x01,0x01,0x01,0x01, /*26 */
+        0x3d,0xad,0x72,0x1b, /*30 */
+
+        0x11,0x11,
+        0x11,0x11,
+
+        0x00,0x6d,
+        0x00,0x00,
+    };
+
+
+
+    StreamDPVmInstructionsRunner runner;
+
+    uint8_t ex[]={5, 
+                 6, 
+                 7, 
+                 1, 
+                 2, 
+                 3, 
+                 4, 
+                 5, 
+                 6, 
+                 7, 
+                 1, 
+                 2, 
+                 3, 
+                 4, 
+                 5, 
+                 6, 
+                 7, 
+                 1, 
+                 2, 
+                 3}; 
+
+    int i;
+    for (i=0; i<20; i++) {
+        runner.run(program_size, 
+                   vm.get_dp_instruction_buffer()->get_program(),
+                   vm.get_bss_ptr(),
+                   test_udp_pkt);
+
+        fprintf(stdout," %d \n",i);
+        //utl_DumpBuffer(stdout,test_udp_pkt,PKT_TEST_SIZE,0);
+        /* not big */
+        EXPECT_EQ(test_udp_pkt[29],0);
+        EXPECT_EQ(test_udp_pkt[28],0);
+        EXPECT_EQ(test_udp_pkt[27],0);
+        EXPECT_EQ(test_udp_pkt[26],ex[i]);
+    }
+
+}
+
+
+/* two fields */
+TEST_F(basic_vm, vm5) {
+
+    StreamVm vm;
+
+    vm.add_instruction( new StreamVmInstructionFlowMan( "var1",4 /* size */,
+                                                        StreamVmInstructionFlowMan::FLOW_VAR_OP_INC,4,1,7 ) 
+                        );
+
+    vm.add_instruction( new StreamVmInstructionFlowMan( "var2",1 /* size */,
+                                                        StreamVmInstructionFlowMan::FLOW_VAR_OP_DEC,25,23,27 ) );
+
+    /* src ip */
+    vm.add_instruction( new StreamVmInstructionWriteToPkt( "var1",26, 0,true)
+                        );
+
+    /* change TOS */
+    vm.add_instruction( new StreamVmInstructionWriteToPkt( "var2",15, 0,true)
+                        );
+
+    vm.add_instruction( new StreamVmInstructionFixChecksumIpv4(14) );
+
+    vm.set_packet_size(128);
+
+    vm.compile();
+
+
+    uint32_t program_size=vm.get_dp_instruction_buffer()->get_program_size();
+
+    printf (" program size : %lu \n",(ulong)program_size);
+
+
+    vm.Dump(stdout);
+
+    #define PKT_TEST_SIZE (14+20+4+4)
+    uint8_t test_udp_pkt[PKT_TEST_SIZE]={ 
+        0x00,0x00,0x00,0x01,0x00,0x00,
+        0x00,0x00,0x00,0x01,0x00,0x00,
+        0x08,0x00,
+
+        0x45,0x00,0x00,0x81, /*14 */
+        0xaf,0x7e,0x00,0x00, /*18 */
+        0x12,0x11,0xd9,0x23, /*22 */
+        0x01,0x01,0x01,0x01, /*26 */
+        0x3d,0xad,0x72,0x1b, /*30 */
+
+        0x11,0x11,           /*34 */
+        0x11,0x11,
+
+        0x00,0x6d,
+        0x00,0x00,
+    };
+
+
+
+    StreamDPVmInstructionsRunner runner;
+
+    uint8_t ex[]={5, 
+                 6, 
+                 7, 
+                 1, 
+                 2, 
+                 3, 
+                 4, 
+                 5, 
+                 6, 
+                 7, 
+                 1, 
+                 2, 
+                 3, 
+                 4, 
+                 5, 
+                 6, 
+                 7, 
+                 1, 
+                 2, 
+                 3}; 
+
+         uint8_t ex_tos[]={0x18, 
+                      0x17, 
+                      0x1b, 
+                      0x1a, 
+                      0x19, 
+                      0x18, 
+                      0x17, 
+                      0x1b, 
+                     0x1a, 
+                     0x19, 
+                     0x18, 
+                     0x17, 
+             0x1b, 
+            0x1a, 
+            0x19, 
+            0x18, 
+            0x17, 
+             0x1b, 
+            0x1a, 
+            0x19, 
+            0x18, 
+            0x17, 
+
+             0x1b, 
+            0x1a, 
+            0x19, 
+            0x18, 
+            0x17, 
+
+             0x1b, 
+            0x1a, 
+            0x19, 
+            0x18, 
+            0x17, 
+
+             0x1b, 
+            0x1a, 
+            0x19, 
+            0x18, 
+            0x17, 
+         }; 
+
+    int i;
+    for (i=0; i<20; i++) {
+        runner.run(program_size, 
+                   vm.get_dp_instruction_buffer()->get_program(),
+                   vm.get_bss_ptr(),
+                   test_udp_pkt);
+
+        fprintf(stdout," %d \n",i);
+        //utl_DumpBuffer(stdout,test_udp_pkt,PKT_TEST_SIZE,0);
+        /* not big */
+        EXPECT_EQ(test_udp_pkt[29],ex[i]);
+        EXPECT_EQ(test_udp_pkt[28],0);
+        EXPECT_EQ(test_udp_pkt[27],0);
+        EXPECT_EQ(test_udp_pkt[26],0);
+
+        /* check tos */
+        EXPECT_EQ(test_udp_pkt[15],ex_tos[i]);
+    }
+}
+
+/* -load file, write to file  */
+TEST_F(basic_vm, vm6) {
+
+
+
+    StreamVm vm;
+
+    vm.add_instruction( new StreamVmInstructionFlowMan( "var1",4 /* size */,
+                                                        StreamVmInstructionFlowMan::FLOW_VAR_OP_INC,0x10000001,0x10000001,0x100000fe) 
+                        );
+
+    vm.add_instruction( new StreamVmInstructionFlowMan( "var2",1 /* size */,
+                                                        StreamVmInstructionFlowMan::FLOW_VAR_OP_DEC,25,23,27 ) );
+
+    /* src ip */
+    vm.add_instruction( new StreamVmInstructionWriteToPkt( "var1",26, 0,true)
+                        );
+
+    /* change TOS */
+    vm.add_instruction( new StreamVmInstructionWriteToPkt( "var2",15, 0,true)
+                        );
+
+    vm.add_instruction( new StreamVmInstructionFixChecksumIpv4(14) );
+
+    vm.set_packet_size(128);
+
+    vm.compile();
+
+
+    uint32_t program_size=vm.get_dp_instruction_buffer()->get_program_size();
+
+    printf (" program size : %lu \n",(ulong)program_size);
+
+
+    vm.Dump(stdout);
+
+    CPcapLoader pcap;
+    pcap.load_pcap_file("cap2/udp_64B.pcap",0);
+
+    
+
+    CFileWriterBase * lpWriter=CCapWriterFactory::CreateWriter(LIBPCAP,(char *)"exp/udp_64B_vm6.pcap");
+    assert(lpWriter);
+
+
+    StreamDPVmInstructionsRunner runner;
+
+    int i;
+    for (i=0; i<20; i++) {
+        runner.run(program_size, 
+                   vm.get_dp_instruction_buffer()->get_program(),
+                   vm.get_bss_ptr(),
+                   (uint8_t*)pcap.m_raw.raw);
+
+        //utl_DumpBuffer(stdout,pcap.m_raw.raw,pcap.m_raw.pkt_len,0);
+        assert(lpWriter->write_packet(&pcap.m_raw));
+    }
+
+    delete lpWriter;
+
+    CErfCmp cmp;
+
+    bool res1=cmp.compare("exp/udp_64B_vm6.pcap","exp/udp_64B_vm6-ex.pcap");
+    EXPECT_EQ(1, res1?1:0);
+}
+
+/* test client command */
+TEST_F(basic_vm, vm7) {
+
+
+
+    StreamVm vm;
+
+    vm.add_instruction( new StreamVmInstructionFlowClient( "cl1",
+                                                           0x10000001,
+                                                           0x10000004,
+                                                           1025,
+                                                           1027,
+                                                           100,
+                                                           0) );
+
+    /* src ip */
+    vm.add_instruction( new StreamVmInstructionWriteToPkt( "cl1.ip",26, 0,true)
+                        );
+
+    vm.add_instruction( new StreamVmInstructionFixChecksumIpv4(14) );
+
+    /* src port */
+    vm.add_instruction( new StreamVmInstructionWriteToPkt( "cl1.port",34, 0,true)
+                        );
+
+
+    vm.set_packet_size(128);
+
+    vm.compile();
+
+
+    uint32_t program_size=vm.get_dp_instruction_buffer()->get_program_size();
+
+    printf (" program size : %lu \n",(ulong)program_size);
+
+
+    vm.Dump(stdout);
+
+    CPcapLoader pcap;
+    pcap.load_pcap_file("cap2/udp_64B.pcap",0);
+
+    
+
+    CFileWriterBase * lpWriter=CCapWriterFactory::CreateWriter(LIBPCAP,(char *)"exp/udp_64B_vm7.pcap");
+    assert(lpWriter);
+
+
+    StreamDPVmInstructionsRunner runner;
+
+    int i;
+    for (i=0; i<20; i++) {
+        runner.run(program_size, 
+                   vm.get_dp_instruction_buffer()->get_program(),
+                   vm.get_bss_ptr(),
+                   (uint8_t*)pcap.m_raw.raw);
+
+        assert(lpWriter->write_packet(&pcap.m_raw));
+    }
+
+    delete lpWriter;
+
+    CErfCmp cmp;
+
+    bool res1=cmp.compare("exp/udp_64B_vm7.pcap","exp/udp_64B_vm7-ex.pcap");
+    EXPECT_EQ(1, res1?1:0);
+}
+
+TEST_F(basic_vm, vm8) {
+
+
+
+    StreamVm vm;
+
+    vm.add_instruction( new StreamVmInstructionFlowClient( "cl1",
+                                                           0x10000001,
+                                                           0x10000006,
+                                                           1025,
+                                                           1027,
+                                                           4,
+                                                           0) );
+
+    /* src ip */
+    vm.add_instruction( new StreamVmInstructionWriteToPkt( "cl1.ip",26, 0,true)
+                        );
+
+    vm.add_instruction( new StreamVmInstructionFixChecksumIpv4(14) );
+
+    /* src port */
+    vm.add_instruction( new StreamVmInstructionWriteToPkt( "cl1.port",34, 0,true)
+                        );
+
+
+    vm.set_packet_size(128);
+
+    vm.compile();
+
+
+    uint32_t program_size=vm.get_dp_instruction_buffer()->get_program_size();
+
+    printf (" program size : %lu \n",(ulong)program_size);
+
+
+    vm.Dump(stdout);
+
+    CPcapLoader pcap;
+    pcap.load_pcap_file("cap2/udp_64B.pcap",0);
+
+    
+
+    CFileWriterBase * lpWriter=CCapWriterFactory::CreateWriter(LIBPCAP,(char *)"exp/udp_64B_vm8.pcap");
+    assert(lpWriter);
+
+
+    StreamDPVmInstructionsRunner runner;
+
+    int i;
+    for (i=0; i<20; i++) {
+        runner.run(program_size, 
+                   vm.get_dp_instruction_buffer()->get_program(),
+                   vm.get_bss_ptr(),
+                   (uint8_t*)pcap.m_raw.raw);
+
+        assert(lpWriter->write_packet(&pcap.m_raw));
+    }
+
+    delete lpWriter;
+
+    CErfCmp cmp;
+
+    bool res1=cmp.compare("exp/udp_64B_vm8.pcap","exp/udp_64B_vm8-ex.pcap");
+    EXPECT_EQ(1, res1?1:0);
+}
+
+static void vm_build_program_seq(StreamVm & vm,
+                                 uint16_t packet_size,
+                                 bool should_compile){
+
+    vm.add_instruction( new StreamVmInstructionFlowClient( "tuple_gen",
+                                                           0x10000001,
+                                                           0x10000006,
+                                                           1025,
+                                                           1027,
+                                                           20,
+                                                           0) );
+
+    /* src ip */
+    vm.add_instruction( new StreamVmInstructionWriteToPkt( "tuple_gen.ip",26, 0,true)
+                        );
+
+    vm.add_instruction( new StreamVmInstructionFixChecksumIpv4(14) );
+
+    /* src port */
+    vm.add_instruction( new StreamVmInstructionWriteToPkt( "tuple_gen.port",34, 0,true)
+                        );
+
+
+    vm.set_packet_size(packet_size);
+
+    if (should_compile) {
+        vm.compile();
+    }
+}
+
+
+TEST_F(basic_vm, vm9) {
+
+
+    StreamVm vm;
+
+    vm_build_program_seq(vm,128, true);
+
+    printf(" max packet update %lu \n",(ulong)vm.get_max_packet_update_offset());
+
+    EXPECT_EQ(36,vm.get_max_packet_update_offset());
+
+    uint32_t program_size=vm.get_dp_instruction_buffer()->get_program_size();
+
+    printf (" program size : %lu \n",(ulong)program_size);
+
+
+    vm.Dump(stdout);
+
+    CPcapLoader pcap;
+    pcap.load_pcap_file("cap2/udp_64B.pcap",0);
+
+    
+
+    CFileWriterBase * lpWriter=CCapWriterFactory::CreateWriter(LIBPCAP,(char *)"exp/udp_64B_vm9.pcap");
+    assert(lpWriter);
+
+
+    StreamDPVmInstructionsRunner runner;
+
+    int i;
+    for (i=0; i<30; i++) {
+        runner.run(program_size, 
+                   vm.get_dp_instruction_buffer()->get_program(),
+                   vm.get_bss_ptr(),
+                   (uint8_t*)pcap.m_raw.raw);
+
+        assert(lpWriter->write_packet(&pcap.m_raw));
+    }
+
+    delete lpWriter;
+
+    CErfCmp cmp;
+
+    bool res1=cmp.compare("exp/udp_64B_vm9.pcap","exp/udp_64B_vm9-ex.pcap");
+    EXPECT_EQ(1, res1?1:0);
+}
+
+
+/* test vmDP object */
+TEST_F(basic_vm, vm10) {
+
+    StreamVm vm;
+
+    vm_build_program_seq(vm,128, true);
+
+    printf(" max packet update %lu \n",(ulong)vm.get_max_packet_update_offset());
+
+    EXPECT_EQ(36,vm.get_max_packet_update_offset());
+
+    StreamVmDp * lpDpVm =vm.cloneAsVmDp();
+
+    EXPECT_EQ(lpDpVm->get_bss_size(),vm.get_bss_size());
+
+    uint32_t program_size=vm.get_dp_instruction_buffer()->get_program_size();
+
+    printf (" program size : %lu \n",(ulong)program_size);
+
+
+    vm.Dump(stdout);
+
+    CPcapLoader pcap;
+    pcap.load_pcap_file("cap2/udp_64B.pcap",0);
+
+    
+
+    CFileWriterBase * lpWriter=CCapWriterFactory::CreateWriter(LIBPCAP,(char *)"exp/udp_64B_vm9.pcap");
+    assert(lpWriter);
+
+
+    StreamDPVmInstructionsRunner runner;
+
+    int i;
+    for (i=0; i<30; i++) {
+        
+        runner.run(lpDpVm->get_program_size(), 
+                   lpDpVm->get_program(),
+                   lpDpVm->get_bss(),
+                   (uint8_t*)pcap.m_raw.raw);
+
+        assert(lpWriter->write_packet(&pcap.m_raw));
+    }
+
+    delete lpWriter;
+
+    CErfCmp cmp;
+    delete  lpDpVm;
+
+    bool res1=cmp.compare("exp/udp_64B_vm9.pcap","exp/udp_64B_vm9-ex.pcap");
+    EXPECT_EQ(1, res1?1:0);
+}
+
+
+
+//////////////////////////////////////////////////////
+
+                                           
 #define EXPECT_EQ_UINT32(a,b) EXPECT_EQ((uint32_t)(a),(uint32_t)(b))
 
 
@@ -274,96 +1163,6 @@ public:
 };
 
 
-class CPcapLoader {
-public:
-    CPcapLoader();
-    ~CPcapLoader();
-
-
-public:
-    bool load_pcap_file(std::string file,int pkt_id=0);
-    void update_ip_src(uint32_t ip_addr);
-    void clone_packet_into_stream(TrexStream * stream);
-    void dump_packet();
-
-public:
-    bool                    m_valid;
-    CCapPktRaw              m_raw;
-    CPacketIndication       m_pkt_indication;
-};
-
-CPcapLoader::~CPcapLoader(){
-}
-
-bool CPcapLoader::load_pcap_file(std::string cap_file,int pkt_id){
-    m_valid=false;
-    CPacketParser parser;
-
-    CCapReaderBase * lp=CCapReaderFactory::CreateReader((char *)cap_file.c_str(),0);
-
-    if (lp == 0) {
-        printf(" ERROR file %s does not exist or not supported \n",(char *)cap_file.c_str());
-        return false;
-    }
-
-    int cnt=0;
-    bool found =false;
-
-
-    while ( true ) {
-        /* read packet */
-        if ( lp->ReadPacket(&m_raw) ==false ){
-            break;
-        }
-        if (cnt==pkt_id) {
-            found = true;
-            break;
-        }
-        cnt++;
-    }
-    if ( found ){
-        if ( parser.ProcessPacket(&m_pkt_indication, &m_raw) ){
-            m_valid = true;
-        }
-    }
-
-    delete lp;
-    return (m_valid);
-}
-
-void CPcapLoader::update_ip_src(uint32_t ip_addr){
-
-    if ( m_pkt_indication.l3.m_ipv4 ) {
-        m_pkt_indication.l3.m_ipv4->setSourceIp(ip_addr);
-        m_pkt_indication.l3.m_ipv4->updateCheckSum();
-    }
-}           
-
-void CPcapLoader::clone_packet_into_stream(TrexStream * stream){
-
-    uint16_t pkt_size=m_raw.getTotalLen();
-
-    uint8_t      *binary = new uint8_t[pkt_size];
-    memcpy(binary,m_raw.raw,pkt_size);
-    stream->m_pkt.binary = binary;
-    stream->m_pkt.len    = pkt_size;
-}
-
-
-
-
-CPcapLoader::CPcapLoader(){
-
-}
-
-void CPcapLoader::dump_packet(){
-    if (m_valid ) {
-        m_pkt_indication.Dump(stdout,1);
-    }else{
-        fprintf(stdout," no packets were found \n");
-    }
-}
-
 
 TEST_F(basic_stl, load_pcap_file) {
     printf (" stateles %d \n",(int)sizeof(CGenNodeStateless));
@@ -435,11 +1234,9 @@ TEST_F(basic_stl, basic_pause_resume0) {
 
      // stream - clean 
 
-     TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/);
-
-     assert(compile.compile(streams, comp_obj) );
-
-     TrexStatelessDpStart * lpStartCmd = new TrexStatelessDpStart(port_id, 0, comp_obj.clone(), 10.0 /*sec */ );
+     std::vector<TrexStreamsCompiledObj *> objs;
+     assert(compile.compile(port_id, streams, objs));
+     TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ );
 
      t1.m_msg_queue.add_msg(lpStartCmd);
 
@@ -499,14 +1296,9 @@ void CBBStartStopDelay2::call_after_init(CBasicStl * m_obj){
     streams.push_back(stream1);
 
     // stream - clean 
-
-    TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/);
-
-    assert(compile.compile(streams, comp_obj) );
-
-
-    /* start with different event id */
-    TrexStatelessDpStart * lpStartCmd = new TrexStatelessDpStart(m_port_id, 1, comp_obj.clone(), 10.0 /*sec */ );
+    std::vector<TrexStreamsCompiledObj *>objs;
+    assert(compile.compile(port_id, streams, objs));
+    TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 1, objs[0], 10.0 /*sec */ );
 
 
     m_obj->m_msg_queue.add_command(m_core,lpStopCmd, 5.0); /* command in delay of 5 sec */
@@ -552,12 +1344,9 @@ TEST_F(basic_stl, single_pkt_bb_start_stop_delay2) {
      streams.push_back(stream1);
 
      // stream - clean 
-
-     TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/);
-
-     assert(compile.compile(streams, comp_obj) );
-
-     TrexStatelessDpStart * lpStartCmd = new TrexStatelessDpStart(port_id, 0, comp_obj.clone(), 10.0 /*sec */ );
+     std::vector<TrexStreamsCompiledObj *>objs;
+     assert(compile.compile(port_id, streams, objs));
+     TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ );
 
      t1.m_msg_queue.add_msg(lpStartCmd);
 
@@ -633,12 +1422,9 @@ TEST_F(basic_stl, single_pkt_bb_start_stop_delay1) {
      streams.push_back(stream1);
 
      // stream - clean 
-
-     TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/);
-
-     assert(compile.compile(streams, comp_obj) );
-
-     TrexStatelessDpStart * lpStartCmd = new TrexStatelessDpStart(port_id, 0, comp_obj.clone(), 10.0 /*sec */ );
+     std::vector<TrexStreamsCompiledObj *>objs;
+     assert(compile.compile(port_id, streams, objs));
+     TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ );
 
      t1.m_msg_queue.add_msg(lpStartCmd);
 
@@ -687,12 +1473,10 @@ TEST_F(basic_stl, single_pkt_bb_start_stop3) {
      streams.push_back(stream1);
 
      // stream - clean 
+     std::vector<TrexStreamsCompiledObj *>objs;
+     assert(compile.compile(port_id, streams, objs));
+     TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ );
 
-     TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/);
-
-     assert(compile.compile(streams, comp_obj) );
-
-     TrexStatelessDpStart * lpStartCmd = new TrexStatelessDpStart(port_id, 0, comp_obj.clone(), 10.0 /*sec */ );
      TrexStatelessDpStop * lpStopCmd = new TrexStatelessDpStop(port_id);
      TrexStatelessDpStop * lpStopCmd1 = new TrexStatelessDpStop(port_id);
 
@@ -740,14 +1524,12 @@ TEST_F(basic_stl, single_pkt_bb_start_stop2) {
      streams.push_back(stream1);
 
      // stream - clean 
+     std::vector<TrexStreamsCompiledObj *>objs;
+     assert(compile.compile(port_id, streams, objs));
+     TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ );
 
-     TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/);
-
-     assert(compile.compile(streams, comp_obj) );
-
-     TrexStatelessDpStart * lpStartCmd = new TrexStatelessDpStart(port_id, 0, comp_obj.clone(), 10.0 /*sec */ );
      TrexStatelessDpStop * lpStopCmd = new TrexStatelessDpStop(port_id);
-     TrexStatelessDpStart * lpStartCmd1 = new TrexStatelessDpStart(port_id, 0, comp_obj.clone(), 10.0 /*sec */ );
+     TrexStatelessDpStart * lpStartCmd1 = new TrexStatelessDpStart(port_id, 0, objs[0]->clone(), 10.0 /*sec */ );
 
 
      t1.m_msg_queue.add_msg(lpStartCmd);
@@ -795,12 +1577,10 @@ TEST_F(basic_stl, single_pkt_bb_start_stop) {
      streams.push_back(stream1);
 
      // stream - clean 
+     std::vector<TrexStreamsCompiledObj *>objs;
+     assert(compile.compile(port_id, streams, objs));
+     TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ );
 
-     TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/);
-
-     assert(compile.compile(streams, comp_obj) );
-
-     TrexStatelessDpStart * lpStartCmd = new TrexStatelessDpStart(port_id, 0, comp_obj.clone(), 10.0 /*sec */ );
      TrexStatelessDpStop * lpStopCmd = new TrexStatelessDpStop(port_id);
 
 
@@ -880,14 +1660,13 @@ TEST_F(basic_stl, simple_prog4) {
      streams.push_back(stream2);
 
 
-     TrexStreamsCompiledObj comp_obj(0,1.0);
-
-     EXPECT_TRUE(compile.compile(streams, comp_obj) );
+     uint8_t port_id = 0;
+     std::vector<TrexStreamsCompiledObj *>objs;
+     assert(compile.compile(port_id, streams, objs));
+     TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 0, objs[0], 20.0 /*sec */ );
 
-     TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(0, 0, comp_obj.clone(), 20.0 );
 
-
-     t1.m_msg = lpstart;
+     t1.m_msg = lpStartCmd;
 
      bool res=t1.init();
 
@@ -950,11 +1729,10 @@ TEST_F(basic_stl, simple_prog3) {
      streams.push_back(stream2);
 
 
-     TrexStreamsCompiledObj comp_obj(0,1.0);
-
-     EXPECT_TRUE(compile.compile(streams, comp_obj) );
-
-     TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(0, 0, comp_obj.clone(), 50.0 );
+     uint8_t port_id = 0;
+     std::vector<TrexStreamsCompiledObj *>objs;
+     assert(compile.compile(port_id, streams, objs));
+     TrexStatelessDpStart *lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], 50.0 /*sec */ );
 
 
      t1.m_msg = lpstart;
@@ -1011,13 +1789,10 @@ TEST_F(basic_stl, simple_prog2) {
      pcap.clone_packet_into_stream(stream2);
      streams.push_back(stream2);
 
-
-     TrexStreamsCompiledObj comp_obj(0,1.0);
-
-     EXPECT_TRUE(compile.compile(streams, comp_obj) );
-
-     TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(0, 0, comp_obj.clone(), 10.0 );
-
+     uint8_t port_id = 0;
+     std::vector<TrexStreamsCompiledObj *>objs;
+     assert(compile.compile(port_id, streams, objs));
+     TrexStatelessDpStart *lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ );
 
      t1.m_msg = lpstart;
 
@@ -1074,11 +1849,10 @@ TEST_F(basic_stl, simple_prog1) {
      streams.push_back(stream2);
 
 
-     TrexStreamsCompiledObj comp_obj(0,1.0);
-
-     EXPECT_TRUE(compile.compile(streams, comp_obj) );
-
-     TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(0, 0, comp_obj.clone(), 10.0 );
+     uint8_t port_id = 0;
+     std::vector<TrexStreamsCompiledObj *>objs;
+     assert(compile.compile(port_id, streams, objs));
+     TrexStatelessDpStart *lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ );
 
 
      t1.m_msg = lpstart;
@@ -1119,12 +1893,10 @@ TEST_F(basic_stl, single_pkt_burst1) {
 
      streams.push_back(stream1);
 
-     TrexStreamsCompiledObj comp_obj(0,1.0);
-
-     assert(compile.compile(streams, comp_obj) );
-
-     TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(0, 0, comp_obj.clone(), 10.0 );
-
+     uint8_t port_id = 0;
+     std::vector<TrexStreamsCompiledObj *>objs;
+     assert(compile.compile(port_id, streams, objs));
+     TrexStatelessDpStart *lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ );
 
      t1.m_msg = lpstart;
 
@@ -1170,11 +1942,9 @@ TEST_F(basic_stl, single_pkt) {
 
      // stream - clean 
 
-     TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/);
-
-     assert(compile.compile(streams, comp_obj) );
-
-     TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(port_id, 0, comp_obj.clone(), 10.0 /*sec */ );
+     std::vector<TrexStreamsCompiledObj *>objs;
+     assert(compile.compile(port_id, streams, objs));
+     TrexStatelessDpStart *lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ );
 
 
      t1.m_msg = lpstart;
@@ -1226,24 +1996,117 @@ TEST_F(basic_stl, multi_pkt1) {
      streams.push_back(stream2);
 
 
+     // stream - clean
+     uint8_t port_id = 0;
+     std::vector<TrexStreamsCompiledObj *>objs;
+     assert(compile.compile(port_id, streams, objs));
+     TrexStatelessDpStart *lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ );
+
+     t1.m_msg = lpstart;
+
+     bool res=t1.init();
+
+     delete stream1 ;
+     delete stream2 ;
+
+     EXPECT_EQ_UINT32(1, res?1:0)<< "pass";
+}
+
+
+class CEnableVm {
+public:
+    void run(bool full_packet,double duration );
+public:
+    std::string    m_input_packet; //"cap2/udp_64B.pcap"
+    std::string    m_out_file;     //"exp/stl_vm_enable0";
+};
+
+void CEnableVm::run(bool full_packet,double duration=10.0){
+
+    CBasicStl t1;
+    CParserOption * po =&CGlobalInfo::m_options;
+    po->preview.setVMode(7);
+    po->preview.setFileWrite(true);
+    po->out_file =m_out_file; 
+
+     TrexStreamsCompiler compile;
+
+     uint8_t port_id=0;
+
+     std::vector<TrexStream *> streams;
+
+     TrexStream * stream1 = new TrexStream(TrexStream::stCONTINUOUS,0,0);
+
+     stream1->set_pps(1.0);
+     
+     stream1->m_enabled = true;
+     stream1->m_self_start = true;
+     stream1->m_port_id= port_id;
+
+     CPcapLoader pcap;
+     pcap.load_pcap_file(m_input_packet,0);
+     pcap.update_ip_src(0x10000001);
+     pcap.clone_packet_into_stream(stream1);
+
+     uint16_t pkt_size=pcap.m_raw.pkt_len;
+
+     vm_build_program_seq(stream1->m_vm,pkt_size, false);
+     #if 0
+     if ( full_packet ){
+         EXPECT_EQ(stream1->m_vm_prefix_size,pkt_size);
+     }else{
+         EXPECT_EQ(stream1->m_vm_prefix_size,35);
+     }
+     #endif
+
+                                    
+     streams.push_back(stream1);
+
      // stream - clean 
-     TrexStreamsCompiledObj comp_obj(0,1.0);
+     std::vector<TrexStreamsCompiledObj *> objs;
 
-     assert(compile.compile(streams, comp_obj) );
+     assert(compile.compile(port_id,streams, objs) );
+
+     TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], duration /*sec */ );
 
-     TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(0, 0, comp_obj.clone(), 10 );
 
      t1.m_msg = lpstart;
 
      bool res=t1.init();
 
      delete stream1 ;
-     delete stream2 ;
 
      EXPECT_EQ_UINT32(1, res?1:0)<< "pass";
 }
 
 
+TEST_F(basic_stl, vm_enable0) {
+
+    CEnableVm vm_test;
+    vm_test.m_out_file = "exp/stl_vm_enable0";
+    vm_test.m_input_packet = "cap2/udp_64B.pcap";
+    vm_test.run(true);
+}
+
+
+TEST_F(basic_stl, vm_enable1) {
+
+    CEnableVm vm_test;
+    vm_test.m_out_file = "exp/stl_vm_enable1";
+    vm_test.m_input_packet = "stl/udp_594B_no_crc.pcap";
+    vm_test.run(false);
+}
+
+
+
+TEST_F(basic_stl, vm_enable2) {
+
+    CEnableVm vm_test;
+    vm_test.m_out_file = "exp/stl_vm_enable2";
+    vm_test.m_input_packet = "cap2/udp_64B.pcap";
+    vm_test.run(true,50.0);
+}
+
 
 
 
@@ -1290,11 +2153,10 @@ TEST_F(basic_stl, multi_pkt2) {
 
 
      // stream - clean 
-     TrexStreamsCompiledObj comp_obj(0,5.0);
-
-     assert(compile.compile(streams, comp_obj) );
-
-     TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(0, 0, comp_obj.clone(), 10 );
+     uint8_t port_id = 0;
+     std::vector<TrexStreamsCompiledObj *>objs;
+     assert(compile.compile(port_id, streams, objs, 1, 5.0));
+     TrexStatelessDpStart *lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ );
 
      t1.m_msg = lpstart;
 
@@ -1336,11 +2198,10 @@ TEST_F(basic_stl, multi_burst1) {
 
      streams.push_back(stream1);
 
-     TrexStreamsCompiledObj comp_obj(0,1.0);
-
-     assert(compile.compile(streams, comp_obj) );
-
-     TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(0, 0, comp_obj.clone(), 40 );
+     uint8_t port_id = 0;
+     std::vector<TrexStreamsCompiledObj *>objs;
+     assert(compile.compile(port_id, streams, objs));
+     TrexStatelessDpStart *lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], 40.0 /*sec */ );
 
 
      t1.m_msg = lpstart;
@@ -1370,10 +2231,9 @@ TEST_F(basic_stl, compile_bad_1) {
 
      streams.push_back(stream1);
 
-     TrexStreamsCompiledObj comp_obj(0,1.0);
-
      std::string err_msg;
-     EXPECT_FALSE(compile.compile(streams, comp_obj, &err_msg));
+     std::vector<TrexStreamsCompiledObj *>objs;
+     EXPECT_FALSE(compile.compile(0, streams, objs, 1, 1, &err_msg));
 
      delete stream1;
 
@@ -1403,10 +2263,12 @@ TEST_F(basic_stl, compile_bad_2) {
      streams.push_back(stream1);
      streams.push_back(stream2);
 
-     TrexStreamsCompiledObj comp_obj(0,1.0);
 
+     uint8_t port_id = 0;
      std::string err_msg;
-     EXPECT_FALSE(compile.compile(streams, comp_obj, &err_msg));
+     std::vector<TrexStreamsCompiledObj *>objs;
+     EXPECT_FALSE(compile.compile(port_id, streams, objs, 1, 1, &err_msg));
+
 
      delete stream1;
      delete stream2;
@@ -1482,10 +2344,10 @@ TEST_F(basic_stl, compile_bad_3) {
      streams.push_back(stream);
 
      /* compile */
-     TrexStreamsCompiledObj comp_obj(0,1.0);
-
      std::string err_msg;
-     EXPECT_FALSE(compile.compile(streams, comp_obj, &err_msg));
+     std::vector<TrexStreamsCompiledObj *>objs;
+     EXPECT_FALSE(compile.compile(0, streams, objs, 1, 1, &err_msg));
+
 
      for (auto stream : streams) {
          delete stream;
@@ -1534,11 +2396,11 @@ TEST_F(basic_stl, compile_with_warnings) {
 
 
      /* compile */
-     TrexStreamsCompiledObj comp_obj(0,1.0);
-
      std::string err_msg;
-     EXPECT_TRUE(compile.compile(streams, comp_obj, &err_msg));
-     
+     std::vector<TrexStreamsCompiledObj *>objs;
+     EXPECT_TRUE(compile.compile(0, streams, objs, 1, 1, &err_msg));
+     delete objs[0];
+
      EXPECT_TRUE(compile.get_last_compile_warnings().size() == 1);
 
      for (auto stream : streams) {
@@ -1573,20 +2435,22 @@ TEST_F(basic_stl, compile_good_stream_id_compres) {
      streams.push_back(stream1);
      streams.push_back(stream2);
 
-     TrexStreamsCompiledObj comp_obj(0,1.0);
-
+     uint8_t port_id = 0;
      std::string err_msg;
-     EXPECT_TRUE(compile.compile(streams, comp_obj, &err_msg));
+     std::vector<TrexStreamsCompiledObj *>objs;
+     EXPECT_TRUE(compile.compile(port_id, streams, objs, 1, 1, &err_msg));
 
      printf(" %s \n",err_msg.c_str());
 
-     comp_obj.Dump(stdout);
+     objs[0]->Dump(stdout);
+
+     EXPECT_EQ_UINT32(objs[0]->get_objects()[0].m_stream->m_stream_id,0);
+     EXPECT_EQ_UINT32(objs[0]->get_objects()[0].m_stream->m_next_stream_id,1);
 
-     EXPECT_EQ_UINT32(comp_obj.get_objects()[0].m_stream->m_stream_id,0);
-     EXPECT_EQ_UINT32(comp_obj.get_objects()[0].m_stream->m_next_stream_id,1);
+     EXPECT_EQ_UINT32(objs[0]->get_objects()[1].m_stream->m_stream_id,1);
+     EXPECT_EQ_UINT32(objs[0]->get_objects()[1].m_stream->m_next_stream_id,0);
 
-     EXPECT_EQ_UINT32(comp_obj.get_objects()[1].m_stream->m_stream_id,1);
-     EXPECT_EQ_UINT32(comp_obj.get_objects()[1].m_stream->m_next_stream_id,0);
+     delete objs[0];
 
      delete stream1;
      delete stream2;
@@ -1648,14 +2512,12 @@ TEST_F(basic_stl, dp_stop_event) {
 
      // stream - clean 
 
-     TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/);
+     std::vector<TrexStreamsCompiledObj *>objs;
+     assert(compile.compile(port_id, streams, objs));
+     TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 17, objs[0], 10.0 /*sec */ );
 
-     assert(compile.compile(streams, comp_obj) );
 
-     TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(port_id, 17, comp_obj.clone(), 10.0 /*sec */ );
-
-
-     t1.m_msg = lpstart;
+     t1.m_msg = lpStartCmd;
 
      /* let me handle these */
      DpToCpHandlerStopEvent handler(17);
@@ -1713,13 +2575,15 @@ TEST_F(basic_stl, graph_generator1) {
      streams.push_back(stream);
 
 
-     const TrexStreamsGraphObj &obj = graph.generate(streams);
-     EXPECT_EQ(obj.get_max_bps(), 405120);
-     EXPECT_EQ(obj.get_max_pps(), 50);
+     const TrexStreamsGraphObj *obj = graph.generate(streams);
+     EXPECT_EQ(obj->get_max_bps(), 405120);
+     EXPECT_EQ(obj->get_max_pps(), 50);
 
      for (auto stream : streams) {
          delete stream;
      }
+
+     delete obj;
 }   
 
 
@@ -1761,15 +2625,17 @@ TEST_F(basic_stl, graph_generator2) {
 
     streams.push_back(stream);
 
-    const TrexStreamsGraphObj &obj = graph.generate(streams);
-    EXPECT_EQ(obj.get_max_pps(), 1000.0);
+    const TrexStreamsGraphObj *obj = graph.generate(streams);
+    EXPECT_EQ(obj->get_max_pps(), 1000.0);
 
-    EXPECT_EQ(obj.get_max_bps(), (1000 * (128 + 4) * 8));
+    EXPECT_EQ(obj->get_max_bps(), (1000 * (128 + 4) * 8));
     
 
     for (auto stream : streams) {
         delete stream;
     }
+
+    delete obj;
 }
 
 /* stress test */
diff --git a/src/latency.cpp b/src/latency.cpp
new file mode 100644
index 00000000..02b54f75
--- /dev/null
+++ b/src/latency.cpp
@@ -0,0 +1,1019 @@
+/*
+ Hanoh Haim
+ Ido Barnea
+ Cisco Systems, Inc.
+*/
+
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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.
+*/
+#include "latency.h"
+#include "bp_sim.h"
+#include "utl_json.h"
+#include <common/basic_utils.h> 
+
+const uint8_t sctp_pkt[]={ 
+
+    0x00,0x04,0x96,0x08,0xe0,0x40,
+    0x00,0x0e,0x2e,0x24,0x37,0x5f,
+    0x08,0x00,
+
+    0x45,0x02,0x00,0x30,
+    0x00,0x00,0x40,0x00,
+    0xff,0x84,0xbd,0x04,
+    0x9b,0xe6,0x18,0x9b, //sIP
+    0xcb,0xff,0xfc,0xc2, //DIP
+
+    0x80,0x44,//SPORT
+    0x00,0x50,//DPORT
+
+    0x00,0x00,0x00,0x00, //checksum 
+
+    0x11,0x22,0x33,0x44, // magic 
+    0x00,0x00,0x00,0x00, //64 bit counter
+    0x00,0x00,0x00,0x00,
+    0x00,0x01,0xa0,0x00, //seq
+    0x00,0x00,0x00,0x00,
+
+};
+
+const uint8_t icmp_pkt[]={
+    0x00,0x04,0x96,0x08,0xe0,0x40,
+    0x00,0x0e,0x2e,0x24,0x37,0x5f,
+    0x08,0x00,
+
+    0x45,0x02,0x00,0x30,
+    0x00,0x00,0x40,0x00,
+    0xff,0x01,0xbd,0x04,
+    0x9b,0xe6,0x18,0x9b, //SIP
+    0xcb,0xff,0xfc,0xc2, //DIP
+
+    0x08, 0x00, 
+    0x01, 0x02,  //checksum
+    0xaa, 0xbb,  // id
+    0x00, 0x00,  // Sequence number
+
+    0x11,0x22,0x33,0x44, // magic 
+    0x00,0x00,0x00,0x00, //64 bit counter
+    0x00,0x00,0x00,0x00,
+    0x00,0x01,0xa0,0x00, //seq
+    0x00,0x00,0x00,0x00,
+
+}; 
+
+
+void CLatencyPktInfo::Create(class CLatencyPktMode *m_l_pkt_info){
+    uint8_t pkt_size = m_l_pkt_info->getPacketLen();
+
+    m_packet = new CCapPktRaw( pkt_size);
+    m_packet->pkt_cnt=0;
+    m_packet->time_sec=0;
+    m_packet->time_nsec=0;
+    memcpy(m_packet->raw, m_l_pkt_info->getPacketData(), pkt_size);
+    m_packet->pkt_len=pkt_size;
+
+    m_pkt_indication.m_packet  =m_packet;
+
+    m_pkt_indication.m_ether = (EthernetHeader *)m_packet->raw;
+    m_pkt_indication.l3.m_ipv4=(IPHeader       *)(m_packet->raw+14);
+    m_pkt_indication.m_is_ipv6 = false;
+    m_pkt_indication.l4.m_icmp=(ICMPHeader *)m_packet->raw+14+20;
+    m_pkt_indication.m_payload=(uint8_t *)m_packet->raw+14+20+16;
+    m_pkt_indication.m_payload_len=0;
+    m_pkt_indication.m_packet_padding=4;
+
+
+    m_pkt_indication.m_ether_offset =0;
+    m_pkt_indication.m_ip_offset =14;
+    m_pkt_indication.m_udp_tcp_offset = 34;
+    m_pkt_indication.m_payload_offset = 34+8;
+
+    CPacketDescriptor * lpd=&m_pkt_indication.m_desc;
+    lpd->Clear();
+    lpd->SetInitSide(true);
+    lpd->SetSwapTuple(false);
+    lpd->SetIsValidPkt(true);
+    lpd->SetIsIcmp(true);
+    lpd->SetIsLastPkt(true);
+    m_pkt_info.Create(&m_pkt_indication);
+
+    memset(&m_dummy_node,0,sizeof(m_dummy_node));
+
+    m_dummy_node.set_socket_id( CGlobalInfo::m_socket.port_to_socket(0) );
+
+    m_dummy_node.m_time =0.1;
+    m_dummy_node.m_pkt_info = &m_pkt_info;
+    m_dummy_node.m_dest_ip  = 0;
+    m_dummy_node.m_src_ip   = 0;
+    m_dummy_node.m_src_port =  0x11;
+    m_dummy_node.m_flow_id =0;
+    m_dummy_node.m_flags =CGenNode::NODE_FLAGS_LATENCY;
+    
+}
+
+rte_mbuf_t * CLatencyPktInfo::generate_pkt(int port_id,uint32_t extern_ip){
+    bool is_client_to_server=(port_id%2==0)?true:false;
+
+    int dual_port_index=(port_id>>1);
+    uint32_t c=m_client_ip.v4;
+    uint32_t s=m_server_ip.v4;
+    if ( extern_ip ){
+        c=extern_ip;
+    }
+
+    if (!is_client_to_server) {
+        /*swap */
+        uint32_t t=c;
+        c=s;
+        s=t;
+    }
+    uint32_t mask=dual_port_index*m_dual_port_mask;
+    if ( extern_ip==0 ){
+       c+=mask;
+    }
+    s+=mask;
+    m_dummy_node.m_src_ip  = c;
+    m_dummy_node.m_dest_ip   = s;
+
+    rte_mbuf_t * m=m_pkt_info.generate_new_mbuf(&m_dummy_node);
+    return (m);
+}
+
+void CLatencyPktInfo::set_ip(uint32_t src,
+                             uint32_t dst,
+                             uint32_t dual_port_mask){
+    m_client_ip.v4=src;
+    m_server_ip.v4=dst;
+    m_dual_port_mask=dual_port_mask;
+}
+
+void CLatencyPktInfo::Delete(){
+    m_pkt_info.Delete();
+    delete m_packet;
+}
+
+void CCPortLatency::reset(){
+    m_rx_seq    =m_tx_seq;
+    m_pad       = 0;
+    m_tx_pkt_err=0;
+    m_tx_pkt_ok =0;
+    m_pkt_ok=0;
+    m_rx_check=0;
+    m_no_magic=0;
+    m_unsup_prot=0;
+    m_no_id=0;
+    m_seq_error=0;
+    m_length_error=0;
+    m_no_ipv4_option=0;
+    m_hist.Reset();
+}
+
+static uint8_t nat_is_port_can_send(uint8_t port_id){
+    uint8_t client_index = (port_id %2);
+    return (client_index ==0 ?1:0);
+}
+
+bool CCPortLatency::Create(CLatencyManager * parent,
+                           uint8_t id,
+                           uint16_t payload_offset,
+                           uint16_t l4_offset,
+                           uint16_t pkt_size,
+                           CCPortLatency * rx_port){
+    m_parent    = parent;
+    m_id        = id;
+    m_tx_seq    =0x12345678;
+    m_icmp_tx_seq = 1;
+    m_icmp_rx_seq = 0;
+    m_l4_offset = l4_offset;
+    m_payload_offset    = payload_offset;
+    m_pkt_size  = pkt_size;
+    m_rx_port   = rx_port;
+    m_nat_can_send = nat_is_port_can_send(m_id);
+    m_nat_learn    = m_nat_can_send;
+    m_nat_external_ip=0;
+
+    m_hist.Create();
+    reset();
+    return (true);
+}
+
+void CCPortLatency::Delete(){
+    m_hist.Delete();
+}
+
+void CCPortLatency::update_packet(rte_mbuf_t * m, int port_id){
+    uint8_t *p=rte_pktmbuf_mtod(m, uint8_t*);
+    bool is_client_to_server=(port_id%2==0)?true:false;
+
+    /* update mac addr dest/src 12 bytes */
+    memcpy(p,CGlobalInfo::m_options.get_dst_src_mac_addr(m_id),12);
+
+    latency_header * h=(latency_header *)(p+m_payload_offset);
+    h->magic = LATENCY_MAGIC | m_id ;
+    h->time_stamp = os_get_hr_tick_64();
+    h->seq = m_tx_seq;
+    m_tx_seq++;
+
+    CLatencyPktMode *c_l_pkt_mode = m_parent->c_l_pkt_mode;
+    c_l_pkt_mode->update_pkt(p + m_l4_offset, is_client_to_server, m_pkt_size - m_l4_offset, &m_icmp_tx_seq);    
+}
+
+
+void CCPortLatency::DumpShortHeader(FILE *fd){
+    
+
+    fprintf(fd," if|   tx_ok , rx_ok  , rx   ,error,    average   ,   max         , Jitter ,  max window \n");
+	fprintf(fd,"   |         ,        , check,     , latency(usec),latency (usec) ,(usec)  ,             \n");
+    fprintf(fd," ---------------------------------------------------------------------------------------------------------------- \n");
+}
+
+
+
+std::string CCPortLatency::get_field(std::string name,float f){
+    char buff[200];
+    sprintf(buff,"\"%s-%d\":%.1f,",name.c_str(),m_id,f);
+    return (std::string(buff));
+}
+
+
+void CCPortLatency::dump_json_v2(std::string & json ){
+    char buff[200];
+    sprintf(buff,"\"port-%d\": {",m_id);
+    json+=std::string(buff);
+    m_hist.dump_json("hist",json);
+    dump_counters_json(json);
+    json+="},";
+}
+
+void CCPortLatency::dump_json(std::string & json ){
+    json += get_field("avg",m_hist.get_average_latency() );
+    json += get_field("max",m_hist.get_max_latency() );
+    json += get_field("c-max",m_hist.get_max_latency_last_update() );
+    json += get_field("error",(float)(m_unsup_prot+m_no_magic+m_no_id+m_seq_error+m_length_error) );
+    json += get_field("jitter",(float)get_jitter_usec() );
+}
+
+
+void CCPortLatency::DumpShort(FILE *fd){
+
+	m_hist.update();
+    fprintf(fd,"%8lu,%8lu,%10lu,%4lu,",                          
+                    m_tx_pkt_ok,
+                    m_pkt_ok,
+                    m_rx_check,
+                    m_unsup_prot+m_no_magic+m_no_id+m_seq_error+m_length_error+m_no_ipv4_option+m_tx_pkt_err
+            );
+
+    fprintf(fd,"   %8.0f  ,%8.0f,%8d ",
+                          m_hist.get_average_latency(),
+                          m_hist.get_max_latency(),
+                          get_jitter_usec()
+                        );
+	fprintf(fd,"     | ");
+	m_hist.DumpWinMax(fd);
+
+}
+
+#define DPL_J(f)  json+=add_json(#f,f);
+#define DPL_J_LAST(f)  json+=add_json(#f,f,true);
+
+void CCPortLatency::dump_counters_json(std::string & json ){
+
+    json+="\"stats\" : {";
+    DPL_J(m_tx_pkt_ok);
+    DPL_J(m_tx_pkt_err);
+    DPL_J(m_pkt_ok);
+    DPL_J(m_unsup_prot);
+    DPL_J(m_no_magic);
+    DPL_J(m_no_id);
+    DPL_J(m_seq_error);
+    DPL_J(m_length_error);
+    DPL_J(m_no_ipv4_option);
+    json+=add_json("m_jitter",get_jitter_usec());
+    /* must be last */
+    DPL_J_LAST(m_rx_check);
+    json+="}";
+
+
+}
+
+void CCPortLatency::DumpCounters(FILE *fd){
+    #define DP_A1(f) if (f) fprintf(fd," %-40s : %llu \n",#f, (unsigned long long)f)
+
+    fprintf(fd," counter  \n");
+    fprintf(fd," -----------\n");
+
+    DP_A1(m_tx_pkt_err);
+    DP_A1(m_tx_pkt_ok);
+    DP_A1(m_pkt_ok);
+    DP_A1(m_unsup_prot);
+    DP_A1(m_no_magic);
+    DP_A1(m_no_id);
+    DP_A1(m_seq_error);
+    DP_A1(m_length_error);
+    DP_A1(m_rx_check);
+    DP_A1(m_no_ipv4_option);
+
+
+    fprintf(fd," -----------\n");
+    m_hist.Dump(fd);
+    fprintf(fd," %-40s : %lu \n","jitter", (ulong)get_jitter_usec());
+}
+
+bool CCPortLatency::dump_packet(rte_mbuf_t * m){
+    fprintf(stdout," %f.03 dump packet ..\n",now_sec());
+	uint8_t *p=rte_pktmbuf_mtod(m, uint8_t*);
+	uint16_t pkt_size=rte_pktmbuf_pkt_len(m);
+    utl_DumpBuffer(stdout,p,pkt_size,0);
+    return (0);
+
+
+
+    if (pkt_size < ( sizeof(CRx_check_header)+14+20) ) {
+        assert(0);
+    }
+    CRx_check_header * lp=(CRx_check_header *)(p+pkt_size-sizeof(CRx_check_header));
+
+    lp->dump(stdout);
+
+
+	uint16_t vlan_offset=0;
+	if ( unlikely( CGlobalInfo::m_options.preview.get_vlan_mode_enable() ) ){
+		vlan_offset=4;
+	}
+
+    (void)vlan_offset;
+
+//	utl_DumpBuffer(stdout,p,pkt_size,0);
+	return (0);
+
+}
+
+bool CCPortLatency::check_rx_check(rte_mbuf_t * m) {
+    m_rx_check++;
+    return (true);
+}
+
+bool CCPortLatency::do_learn(uint32_t external_ip) {
+    m_nat_learn=true;
+    m_nat_can_send=true;
+    m_nat_external_ip=external_ip;
+    return (true);
+}
+
+bool CCPortLatency::check_packet(rte_mbuf_t * m,CRx_check_header * & rx_p) {
+    CSimplePacketParser parser(m);
+    if ( !parser.Parse()  ) {
+        m_unsup_prot++;  // Unsupported protocol
+        return (false);
+    }    
+    CLatencyPktMode *c_l_pkt_mode = m_parent->c_l_pkt_mode;
+    uint16_t pkt_size=rte_pktmbuf_pkt_len(m);
+
+    /* check if CRC was extracted */
+    if ( parser.getPktSize() == pkt_size-4) {
+        // CRC was not extracted by driver (VM E1000 driver issue) extract it
+        pkt_size=pkt_size-4;
+    }
+
+    uint16_t vlan_offset=parser.m_vlan_offset;
+    uint8_t *p=rte_pktmbuf_mtod(m, uint8_t*);
+
+    rx_p = (CRx_check_header *)0;
+
+    bool is_lateancy_pkt =  c_l_pkt_mode->IsLatencyPkt(parser.m_ipv4) & parser.IsLatencyPkt(parser.m_l4 + c_l_pkt_mode->l4_header_len());
+
+    if ( ! is_lateancy_pkt) {
+
+#ifdef NAT_TRACE_
+        printf(" %.3f RX : got packet !!! \n",now_sec() );
+#endif
+
+        /* ipv6+rx-check */
+        if ( parser.m_ipv6 ) {
+            /* if we have ipv6 packet */
+            if (parser.m_protocol == RX_CHECK_V6_OPT_TYPE) {
+                if ( get_is_rx_check_mode() ){
+                    m_rx_check++;
+                    rx_p=(CRx_check_header *)((uint8_t*)parser.m_ipv6  +IPv6Header::DefaultSize);
+                    return (true);
+                }
+
+            }
+            m_seq_error++;
+           return (false);
+        }
+
+        uint8_t opt_len = parser.m_ipv4->getOptionLen();
+        uint8_t *opt_ptr = parser.m_ipv4->getOption();
+        /* Process IP option header(s) */
+        while ( opt_len != 0 ) {
+            switch (*opt_ptr) {
+            case RX_CHECK_V4_OPT_TYPE:
+                    /* rx-check option header */
+                    if ( ( !get_is_rx_check_mode() ) ||
+                        (opt_len < RX_CHECK_LEN) ) {
+                        m_seq_error++;
+                        return (false);
+                    }
+                    m_rx_check++;
+                    rx_p=(CRx_check_header *)opt_ptr;
+                    opt_len -= RX_CHECK_LEN;
+                    opt_ptr += RX_CHECK_LEN;
+                    break;
+            case CNatOption::noIPV4_OPTION:
+                    /* NAT learn option header */
+                    CNatOption *lp;
+                    if ( ( !CGlobalInfo::is_learn_mode() ) ||
+                         (opt_len < CNatOption::noOPTION_LEN) ) {
+                        m_seq_error++;
+                        return (false);
+                    }
+                    lp = (CNatOption *)opt_ptr;
+                    if ( !lp->is_valid_ipv4_magic() ) {
+                        m_no_ipv4_option++;
+                        return (false);
+                    }
+                    m_parent->get_nat_manager()->handle_packet_ipv4(lp,parser.m_ipv4);
+                    opt_len -= CNatOption::noOPTION_LEN;
+                    opt_ptr += CNatOption::noOPTION_LEN;
+                    break;
+            default:
+                    m_seq_error++;
+                    return (false);
+            } // End of switch
+        } // End of while
+
+        return (true);
+    } // End of check for non-latency packet
+    if ( CGlobalInfo::is_learn_mode() && (m_nat_learn ==false) ) {
+        do_learn(parser.m_ipv4->getSourceIp());
+    }
+
+    if ( (pkt_size-vlan_offset) != m_pkt_size ) {
+        m_length_error++;
+        return (false);
+    }
+    c_l_pkt_mode->update_recv(p + m_l4_offset + vlan_offset, &m_icmp_rx_seq, &m_icmp_tx_seq);
+#ifdef LATENCY_DEBUG
+    c_l_pkt_mode->rcv_debug_print(p + m_l4_offset + vlan_offset);
+#endif
+    latency_header * h=(latency_header *)(p+m_payload_offset + vlan_offset);
+    if ( h->seq != m_rx_seq ){
+        m_seq_error++;
+        m_rx_seq =h->seq +1;
+        return (false);
+    }else{
+        m_rx_seq++;
+    }
+    m_pkt_ok++;
+    uint64_t d = (os_get_hr_tick_64() - h->time_stamp );
+    dsec_t ctime=ptime_convert_hr_dsec(d);
+    m_hist.Add(ctime);
+    m_jitter.calc(ctime);
+    return (true);
+}
+
+void CLatencyManager::Delete(){
+    m_pkt_gen.Delete();
+
+    if ( get_is_rx_check_mode() ) {
+        m_rx_check_manager.Delete();
+    }
+    if ( CGlobalInfo::is_learn_mode() ){
+        m_nat_check_manager.Delete();
+    }
+    m_cpu_cp_u.Delete();
+}
+
+/* 0->1
+   1->0 
+   2->3
+   3->2
+*/
+static uint8_t swap_port(uint8_t port_id){
+    uint8_t offset= ((port_id>>1)<<1);
+    uint8_t client_index = (port_id %2);
+    return (offset + (client_index ^ 1));
+}
+
+
+
+bool CLatencyManager::Create(CLatencyManagerCfg * cfg){
+    switch (CGlobalInfo::m_options.get_l_pkt_mode()) {
+    default:
+    case 0:
+        c_l_pkt_mode = (CLatencyPktModeSCTP *) new CLatencyPktModeSCTP(CGlobalInfo::m_options.get_l_pkt_mode());
+        break;
+    case 1:
+    case 2:
+    case 3:
+        c_l_pkt_mode =  (CLatencyPktModeICMP *) new CLatencyPktModeICMP(CGlobalInfo::m_options.get_l_pkt_mode());
+        break;
+    }
+    
+    m_max_ports=cfg->m_max_ports;
+    assert (m_max_ports<=MAX_LATENCY_PORTS);
+    assert ((m_max_ports%2)==0);
+    m_port_mask =0xffffffff;
+    m_do_stop =false;
+    m_is_active =false;
+    m_pkt_gen.Create(c_l_pkt_mode);
+    int i;
+    for (i=0; i<m_max_ports; i++) {
+        CLatencyManagerPerPort * lp=&m_ports[i];
+        CCPortLatency * lpo=&m_ports[swap_port(i)].m_port;
+
+        lp->m_io=cfg->m_ports[i];
+        lp->m_port.Create(this,
+                          i,
+                          m_pkt_gen.get_payload_offset(),
+                          m_pkt_gen.get_l4_offset(),
+                          m_pkt_gen.get_pkt_size(),lpo );
+    }
+    m_cps= cfg->m_cps;
+    m_d_time =ptime_convert_dsec_hr((1.0/m_cps));
+    m_delta_sec =(1.0/m_cps);
+
+        
+    if ( get_is_rx_check_mode() ) {
+        assert(m_rx_check_manager.Create());
+        m_rx_check_manager.m_cur_time= now_sec();
+     }
+
+
+    m_pkt_gen.set_ip(cfg->m_client_ip.v4,cfg->m_server_ip.v4,cfg->m_dual_port_mask);
+    m_cpu_cp_u.Create(&m_cpu_dp_u);
+    if ( CGlobalInfo::is_learn_mode() ){
+        m_nat_check_manager.Create();
+    }
+    return (true);
+}
+
+
+void  CLatencyManager::send_pkt_all_ports(){
+    m_start_time = os_get_hr_tick_64();
+    int i;
+    for (i=0; i<m_max_ports; i++) {
+        if ( m_port_mask & (1<<i)  ){
+            CLatencyManagerPerPort * lp=&m_ports[i];
+            if (lp->m_port.can_send_packet(i%2) ){
+                rte_mbuf_t * m=m_pkt_gen.generate_pkt(i,lp->m_port.external_nat_ip());
+                lp->m_port.update_packet(m, i);
+
+#ifdef LATENCY_DEBUG
+                uint8_t *p = rte_pktmbuf_mtod(m, uint8_t*);
+                c_l_pkt_mode->send_debug_print(p + 34);
+#endif
+                if ( lp->m_io->tx(m) == 0 ){
+                    lp->m_port.m_tx_pkt_ok++;
+                }else{
+                    lp->m_port.m_tx_pkt_err++;
+                }
+
+            }
+        }
+    }
+}
+
+
+void  CLatencyManager::wait_for_rx_dump(){
+	rte_mbuf_t * rx_pkts[64];
+	int i;
+	while ( true  ) {
+		rte_pause();
+		rte_pause();
+		rte_pause();
+		for (i=0; i<m_max_ports; i++) {
+			CLatencyManagerPerPort * lp=&m_ports[i];
+			rte_mbuf_t * m;
+			uint16_t cnt_p = lp->m_io->rx_burst(rx_pkts, 64);
+			if (cnt_p) {
+				int j;
+				for (j=0; j<cnt_p; j++) {
+					m=rx_pkts[j] ;
+					lp->m_port.dump_packet( m);
+					rte_pktmbuf_free(m);
+				}
+			} /*cnt_p*/
+		}/* for*/
+	}
+}
+
+
+void CLatencyManager::handle_rx_pkt(CLatencyManagerPerPort * lp,
+                                    rte_mbuf_t * m){
+    CRx_check_header *rxc = NULL;
+
+    lp->m_port.check_packet(m,rxc);
+    if ( unlikely(rxc!=NULL) ){
+        m_rx_check_manager.handle_packet(rxc);
+    }
+
+    rte_pktmbuf_free(m);
+}
+
+void CLatencyManager::handle_latency_pkt_msg(uint8_t thread_id,
+                                            CGenNodeLatencyPktInfo * msg){
+
+    assert(msg->m_latency_offset==0xdead);
+
+    uint8_t rx_port_index=(thread_id<<1)+(msg->m_dir&1);
+    assert( rx_port_index <m_max_ports ) ;
+    CLatencyManagerPerPort * lp=&m_ports[rx_port_index];
+    handle_rx_pkt(lp,(rte_mbuf_t *)msg->m_pkt);
+}
+
+
+void  CLatencyManager::run_rx_queue_msgs(uint8_t thread_id,
+                                         CNodeRing * r){
+
+    while ( true ) {
+        CGenNode * node;
+        if ( r->Dequeue(node)!=0 ){
+            break;
+        }
+        assert(node);
+
+        CGenNodeMsgBase * msg=(CGenNodeMsgBase *)node;
+
+        uint8_t   msg_type =  msg->m_msg_type;
+        switch (msg_type ) {
+        case CGenNodeMsgBase::LATENCY_PKT:
+            handle_latency_pkt_msg(thread_id,(CGenNodeLatencyPktInfo *) msg);
+            break;
+        default:
+            printf("ERROR latency-thread message type is not valid %d \n",msg_type);
+            assert(0);
+        }
+
+        CGlobalInfo::free_node(node);
+    }
+}
+
+void  CLatencyManager::try_rx_queues(){
+
+    CMessagingManager * rx_dp = CMsgIns::Ins()->getRxDp();
+    uint8_t threads=CMsgIns::Ins()->get_num_threads();
+    int ti;
+    for (ti=0; ti<(int)threads; ti++) {
+        CNodeRing * r = rx_dp->getRingDpToCp(ti);
+        if ( !r->isEmpty() ){
+            run_rx_queue_msgs((uint8_t)ti,r);
+        }
+    }
+}
+
+
+void  CLatencyManager::try_rx(){
+    rte_mbuf_t * rx_pkts[64];
+    int i;
+    for (i=0; i<m_max_ports; i++) {
+        CLatencyManagerPerPort * lp=&m_ports[i];
+        rte_mbuf_t * m;
+        m_cpu_dp_u.start_work();
+        /* try to read 64 packets clean up the queue */
+        uint16_t cnt_p = lp->m_io->rx_burst(rx_pkts, 64);
+        if (cnt_p) {
+            int j;
+            for (j=0; j<cnt_p; j++) {
+                m=rx_pkts[j] ;
+                handle_rx_pkt(lp,m);
+            }
+            /* commit only if there was work to do ! */
+            m_cpu_dp_u.commit();
+          }/* if work */
+      }// all ports
+}
+
+
+void  CLatencyManager::reset(){
+
+    int i;
+    for (i=0; i<m_max_ports; i++) {
+        CLatencyManagerPerPort * lp=&m_ports[i];
+        lp->m_port.reset();
+    }
+
+}
+
+void  CLatencyManager::start(int iter){
+    m_do_stop =false;
+    m_is_active =false;
+    int cnt=0;
+
+    double n_time;
+    CGenNode * node = new CGenNode();
+    node->m_type = CGenNode::FLOW_SYNC;   /* general stuff */
+    node->m_time = now_sec()+0.007;
+    m_p_queue.push(node);
+
+    node = new CGenNode();
+    node->m_type = CGenNode::FLOW_PKT; /* latency */
+    node->m_time = now_sec(); /* 1/cps rate */
+    m_p_queue.push(node);
+    bool do_try_rx_queue =CGlobalInfo::m_options.preview.get_vm_one_queue_enable()?true:false;
+
+
+    while (  !m_p_queue.empty() ) {
+        node = m_p_queue.top();
+        n_time = node->m_time;
+
+        /* wait for event */
+        while ( true ) {
+            double dt = now_sec() - n_time ;
+            if (dt> (0.0)) {
+                break;
+            }
+            if (do_try_rx_queue){
+                try_rx_queues();
+            }
+            try_rx();
+            rte_pause();
+        }
+
+        switch (node->m_type) {
+        case CGenNode::FLOW_SYNC:
+            if ( CGlobalInfo::is_learn_mode() ) {
+                m_nat_check_manager.handle_aging();
+            }
+
+            m_p_queue.pop();
+            node->m_time += SYNC_TIME_OUT;
+            m_p_queue.push(node);
+
+            break;
+        case CGenNode::FLOW_PKT:
+            m_cpu_dp_u.start_work();
+            send_pkt_all_ports();
+            m_p_queue.pop();
+            node->m_time += m_delta_sec;
+            m_p_queue.push(node);
+            m_cpu_dp_u.commit();
+            break;
+        }
+
+        /* this will be called every sync which is 1msec */
+        if ( m_do_stop ) {
+             break;
+        }
+        if ( iter>0   ){
+            if ( ( cnt>iter) ){
+                printf("stop due iter %d\n",iter);
+                break;
+            }
+        } 
+        cnt++;
+    }
+
+    /* free all nodes in the queue */
+    while (!m_p_queue.empty()) {
+        node = m_p_queue.top();
+        m_p_queue.pop();
+        delete node;
+    }
+
+    printf(" latency daemon has stopped\n");
+    if ( get_is_rx_check_mode() ) {
+        m_rx_check_manager.tw_drain();
+    }
+
+}
+
+void  CLatencyManager::stop(){
+    m_do_stop =true;
+}
+
+bool  CLatencyManager::is_active(){
+    return (m_is_active);
+}
+
+
+double CLatencyManager::get_max_latency(){
+    double l=0.0;
+    int i;
+    for (i=0; i<m_max_ports; i++) {
+        CLatencyManagerPerPort * lp=&m_ports[i];
+        if ( l <lp->m_port.m_hist.get_max_latency() ){
+            l=lp->m_port.m_hist.get_max_latency();
+        }
+    }
+    return (l);
+}
+
+double CLatencyManager::get_avr_latency(){
+    double l=0.0;
+    int i;
+    for (i=0; i<m_max_ports; i++) {
+        CLatencyManagerPerPort * lp=&m_ports[i];
+        if ( l <lp->m_port.m_hist.get_average_latency() ){
+            l=lp->m_port.m_hist.get_average_latency();
+        }
+    }
+    return (l);
+}
+
+uint64_t CLatencyManager::get_total_pkt(){
+    int i;
+    uint64_t t=0;
+    for (i=0; i<m_max_ports; i++) {
+        CLatencyManagerPerPort * lp=&m_ports[i];
+        t+=lp->m_port.m_tx_pkt_ok ;
+    }
+    return  t;
+}
+
+uint64_t CLatencyManager::get_total_bytes(){
+    int i;
+    uint64_t t=0;
+    for (i=0; i<m_max_ports; i++) {
+        CLatencyManagerPerPort * lp=&m_ports[i];
+        t+=lp->m_port.m_tx_pkt_ok* (m_pkt_gen.get_pkt_size()+4);
+    }
+    return  t;
+
+}
+
+
+bool   CLatencyManager::is_any_error(){
+    int i;
+    for (i=0; i<m_max_ports; i++) {
+        CLatencyManagerPerPort * lp=&m_ports[i];
+        if ( lp->m_port.is_any_err() ){
+            return (true);
+        }
+    }
+    return  (false);
+}
+
+
+void CLatencyManager::dump_json(std::string & json ){
+    json="{\"name\":\"trex-latecny\",\"type\":0,\"data\":{";
+    int i;
+    for (i=0; i<m_max_ports; i++) {
+        CLatencyManagerPerPort * lp=&m_ports[i];
+        lp->m_port.dump_json(json);
+    }
+
+    json+="\"unknown\":0}}"  ;
+
+}
+
+void CLatencyManager::dump_json_v2(std::string & json ){
+    json="{\"name\":\"trex-latecny-v2\",\"type\":0,\"data\":{";
+    json+=add_json("cpu_util",m_cpu_cp_u.GetVal());
+
+    int i;
+    for (i=0; i<m_max_ports; i++) {
+        CLatencyManagerPerPort * lp=&m_ports[i];
+        lp->m_port.dump_json_v2(json);
+    }
+
+    json+="\"unknown\":0}}"  ;
+
+}
+
+void CLatencyManager::DumpRxCheck(FILE *fd){
+    if ( get_is_rx_check_mode() ) {
+        fprintf(fd," rx checker : \n");
+        m_rx_check_manager.DumpShort(fd);
+        m_rx_check_manager.Dump(fd);
+    }
+}
+
+void CLatencyManager::DumpShortRxCheck(FILE *fd){
+    if ( get_is_rx_check_mode() ) {
+        m_rx_check_manager.DumpShort(fd);
+    }
+}
+
+void CLatencyManager::rx_check_dump_json(std::string & json){
+    if ( get_is_rx_check_mode() ) {
+        m_rx_check_manager.dump_json(json );
+    }
+}
+
+void CLatencyManager::update(){
+    m_cpu_cp_u.Update() ;
+}
+
+void CLatencyManager::DumpShort(FILE *fd){
+    int i;
+    fprintf(fd," Cpu Utilization : %2.1f %%  \n",m_cpu_cp_u.GetVal());
+    CCPortLatency::DumpShortHeader(fd);
+    for (i=0; i<m_max_ports; i++) {
+        fprintf(fd," %d | ",i);
+        CLatencyManagerPerPort * lp=&m_ports[i];
+        lp->m_port.DumpShort(fd);
+        fprintf(fd,"\n");
+    }
+
+
+}
+
+void CLatencyManager::Dump(FILE *fd){
+    int i;
+    fprintf(fd," cpu : %2.1f  %% \n",m_cpu_cp_u.GetVal());
+    for (i=0; i<m_max_ports; i++) {
+        fprintf(fd," port   %d \n",i);
+        fprintf(fd," -----------------\n");
+        CLatencyManagerPerPort * lp=&m_ports[i];
+        lp->m_port.DumpCounters(fd);
+    }
+}
+
+void CLatencyManager::DumpRxCheckVerification(FILE *fd,
+                                              uint64_t total_tx_rx_check){
+    if ( !get_is_rx_check_mode() ) {
+        fprintf(fd," rx_checker is disabled  \n");
+        return;
+    }
+    fprintf(fd," rx_check Tx : %llu \n", (unsigned long long)total_tx_rx_check);
+    fprintf(fd," rx_check Rx : %llu \n", (unsigned long long)m_rx_check_manager.getTotalRx() );
+    fprintf(fd," rx_check verification :" );
+    if (m_rx_check_manager.getTotalRx() == total_tx_rx_check) {
+        fprintf(fd," OK \n" );
+    }else{
+        fprintf(fd," FAIL \n" );
+    }
+}
+
+uint8_t CLatencyPktModeICMP::getPacketLen() {return sizeof(icmp_pkt);}
+const uint8_t *CLatencyPktModeICMP::getPacketData() {return icmp_pkt;}
+void CLatencyPktModeICMP::rcv_debug_print(uint8_t *pkt) {
+    ICMPHeader *m_icmp = (ICMPHeader *)pkt;
+    printf ("received latency ICMP packet code:%d seq:%x\n"
+            , m_icmp->getType(), m_icmp->getSeqNum());
+};
+
+void CLatencyPktModeICMP::send_debug_print(uint8_t *pkt) {
+    ICMPHeader *m_icmp = (ICMPHeader *)pkt;
+    printf ("Sending latency ICMP packet code:%d seq:%d\n", m_icmp->getType(), m_icmp->getSeqNum());
+}
+
+void CLatencyPktModeICMP::update_pkt(uint8_t *pkt, bool is_client_to_server, uint16_t l4_len, uint16_t *tx_seq) {
+    ICMPHeader * m_icmp =(ICMPHeader *)(pkt);
+
+    if (m_submode == L_PKT_SUBMODE_0_SEQ) {
+        m_icmp->setSeqNum(0);
+    } else {
+        m_icmp->setSeqNum(*tx_seq);
+        (*tx_seq)++;
+    }
+
+    if ((!is_client_to_server) && (m_submode == L_PKT_SUBMODE_REPLY)) {
+      m_icmp->setType(0); // echo reply
+    } else {
+      m_icmp->setType(8); // echo request
+    }
+    // ICMP checksum is calculated on payload + ICMP header
+    m_icmp->updateCheckSum(l4_len);
+
+}
+
+bool CLatencyPktModeICMP::IsLatencyPkt(IPHeader *ip) {
+    if (!ip)
+        return false;
+    if (ip->getProtocol() != 0x1)
+        return false;
+    return true;
+};
+
+void CLatencyPktModeICMP::update_recv(uint8_t *pkt, uint16_t *r_seq, uint16_t *t_seq) {
+    ICMPHeader *m_icmp = (ICMPHeader *)(pkt);
+    *r_seq = m_icmp->getSeqNum();
+    // handle wrap around, so can_send_packet will allow us to send
+    if (*r_seq == 0)
+        *t_seq = 0;
+}
+
+
+uint8_t CLatencyPktModeSCTP::getPacketLen() {return sizeof(sctp_pkt);}
+const uint8_t *CLatencyPktModeSCTP::getPacketData() {return sctp_pkt;}
+void CLatencyPktModeSCTP::rcv_debug_print(uint8_t *pkt) {printf("Received latency SCTP packet\n");}
+void CLatencyPktModeSCTP::send_debug_print(uint8_t *pkt) {printf("Sending latency SCTP packet\n");
+    // utl_DumpBuffer(stdout,pkt-20,28,0);
+}
+void CLatencyPktModeSCTP::update_pkt(uint8_t *pkt, bool is_client_to_server, uint16_t l4_len, uint16_t *tx_seq) {}
+bool CLatencyPktModeSCTP::IsLatencyPkt(IPHeader *ip) {
+    if (!ip) {
+        return false;
+    }
+    if (ip->getProtocol() != 0x84) {
+        return false;
+    }
+    return true;
+};
+void CLatencyPktModeSCTP::update_recv(uint8_t *pkt, uint16_t *r_seq, uint16_t *t_seq) {}
diff --git a/src/latency.h b/src/latency.h
new file mode 100644
index 00000000..59481a59
--- /dev/null
+++ b/src/latency.h
@@ -0,0 +1,386 @@
+#ifndef LATENCY_H
+#define LATENCY_H
+/*
+ Hanoh Haim
+ Ido Barnea
+ Cisco Systems, Inc.
+*/
+
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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.
+*/
+#include <bp_sim.h>
+
+#define L_PKT_SUBMODE_NO_REPLY 1
+#define L_PKT_SUBMODE_REPLY 2
+#define L_PKT_SUBMODE_0_SEQ 3
+
+class CLatencyPktInfo {
+public:
+    void Create(class CLatencyPktMode *m_l_pkt_info);
+    void Delete();
+    void set_ip(uint32_t src,
+                uint32_t dst,
+                uint32_t dual_port_mask);
+    rte_mbuf_t * generate_pkt(int port_id,uint32_t extern_ip=0);
+
+    CGenNode   *    getNode(){
+        return (&m_dummy_node);
+    }
+
+    uint16_t get_payload_offset(void){
+        return ( m_pkt_indication.getFastPayloadOffset());
+    }
+
+    uint16_t get_l4_offset(void){
+        return ( m_pkt_indication.getFastTcpOffset());
+    }
+
+    uint16_t get_pkt_size(void){
+        return ( m_packet->pkt_len );
+    }
+
+private:
+    ipaddr_t            m_client_ip;
+    ipaddr_t            m_server_ip;
+    uint32_t            m_dual_port_mask;
+
+    CGenNode            m_dummy_node;
+    CFlowPktInfo        m_pkt_info;
+    CPacketIndication   m_pkt_indication;
+    CCapPktRaw *        m_packet;
+};
+
+
+#define LATENCY_MAGIC 0x12345600
+
+struct  latency_header {
+
+    uint64_t time_stamp;
+    uint32_t magic;
+    uint32_t seq;
+
+    uint8_t get_id(){
+        return( magic & 0xff);
+    }
+};
+
+class CSimplePacketParser {
+public:
+
+    CSimplePacketParser(rte_mbuf_t * m){
+        m_m=m;
+    }
+
+    bool Parse();
+    uint8_t getTTl();
+    uint16_t getPktSize();
+
+    inline bool IsLatencyPkt(uint8_t *p) {
+        latency_header * h=(latency_header *)(p);
+        if ( (h->magic & 0xffffff00) != LATENCY_MAGIC ){
+            return (false);
+        }
+
+        return true;
+    }
+
+
+public:
+    IPHeader *      m_ipv4;
+    IPv6Header *    m_ipv6;
+    uint8_t         m_protocol;
+    uint16_t        m_vlan_offset;
+    uint16_t        m_option_offset;
+    uint8_t *       m_l4;
+private: 
+    rte_mbuf_t *    m_m ;
+};
+
+
+
+class CLatencyManager ;
+
+// per port 
+class CCPortLatency {
+public:
+    bool Create(CLatencyManager * parent,
+                uint8_t id,
+                uint16_t offset,
+                uint16_t l4_offset,
+                uint16_t pkt_size,
+                CCPortLatency * rx_port
+                );
+    void Delete();
+    void reset();
+    bool can_send_packet(int direction){
+        // in icmp_reply mode, can send response from server, only after we got the relevant request
+        // if we got request, we are sure to have NAT translation in place already.
+        if ((CGlobalInfo::m_options.m_l_pkt_mode == L_PKT_SUBMODE_REPLY) && (direction == 1)) {
+            if (m_icmp_tx_seq <= m_icmp_rx_seq)
+                return(true);
+            else
+                return(false);
+        }        
+
+        if ( !CGlobalInfo::is_learn_mode() ) {
+            return(true);
+        }
+        return ( m_nat_can_send );
+    }
+    uint32_t external_nat_ip(){
+        return (m_nat_external_ip);
+    }
+
+    void update_packet(rte_mbuf_t * m, int port_id);
+
+    bool do_learn(uint32_t external_ip);
+
+    bool check_packet(rte_mbuf_t * m,
+                      CRx_check_header * & rx_p);
+    bool check_rx_check(rte_mbuf_t * m);
+
+
+	bool dump_packet(rte_mbuf_t * m);
+
+    void DumpCounters(FILE *fd);
+    void dump_counters_json(std::string & json );
+
+    void DumpShort(FILE *fd);
+    void dump_json(std::string & json );
+    void dump_json_v2(std::string & json );
+
+    uint32_t get_jitter_usec(void){
+        return ((uint32_t)(m_jitter.get_jitter()*1000000.0));
+    }
+
+
+    static void DumpShortHeader(FILE *fd);
+
+    bool is_any_err(){
+        if (  (m_tx_pkt_ok == m_rx_port->m_pkt_ok ) && 
+
+              ((m_unsup_prot+
+                m_no_magic+
+                m_no_id+
+                m_seq_error+
+                m_length_error+m_no_ipv4_option+m_tx_pkt_err)==0) ) {
+            return (false);
+        }
+        return (true);
+    }
+
+    uint16_t get_icmp_tx_seq() {return m_icmp_tx_seq;}
+    uint16_t get_icmp_rx_seq() {return m_icmp_rx_seq;}
+
+private:
+    std::string get_field(std::string name,float f);
+
+    
+private:
+     CLatencyManager * m_parent;
+     CCPortLatency *   m_rx_port; /* corespond rx port  */
+     bool              m_nat_learn;  
+     bool              m_nat_can_send;
+     uint32_t          m_nat_external_ip;
+
+     uint32_t m_tx_seq;
+     uint32_t m_rx_seq;
+
+     uint8_t  m_pad;
+     uint8_t  m_id;
+     uint16_t m_payload_offset;
+     uint16_t m_l4_offset;
+
+     uint16_t m_pkt_size;
+     // following two variables are for the latency ICMP reply mode.
+     // if we want to pass through firewall, we want to send reply only after we got request with same seq num
+     // ICMP seq num of next packet we will transmit
+     uint16_t m_icmp_tx_seq;
+     // ICMP seq num of last request we got
+     uint16_t m_icmp_rx_seq;
+     uint16_t pad1[1];
+
+public:
+     uint64_t m_tx_pkt_ok;
+     uint64_t m_tx_pkt_err;
+
+     uint64_t m_pkt_ok;
+     uint64_t m_unsup_prot;
+     uint64_t m_no_magic;
+     uint64_t m_no_id;
+     uint64_t m_seq_error;
+     uint64_t m_rx_check;
+     uint64_t m_no_ipv4_option;
+
+
+     uint64_t m_length_error;
+     CTimeHistogram  m_hist; /* all window */
+     CJitter         m_jitter; 
+};
+
+
+class CPortLatencyHWBase {
+public:
+    virtual int tx(rte_mbuf_t * m)=0;
+    virtual rte_mbuf_t * rx()=0;
+    virtual uint16_t rx_burst(struct rte_mbuf **rx_pkts, 
+                               uint16_t nb_pkts){
+        return(0);
+    }
+};
+
+
+class CLatencyManagerCfg {
+public:
+    CLatencyManagerCfg (){
+        m_max_ports=0;
+        m_cps=0.0;
+        m_client_ip.v4=0x10000000;
+        m_server_ip.v4=0x20000000;
+        m_dual_port_mask=0x01000000;
+    }
+    uint32_t             m_max_ports;
+    double               m_cps;// CPS
+    CPortLatencyHWBase * m_ports[MAX_LATENCY_PORTS];
+    ipaddr_t             m_client_ip;
+    ipaddr_t             m_server_ip;
+    uint32_t             m_dual_port_mask;
+
+};
+
+
+class CLatencyManagerPerPort {
+public:
+     CCPortLatency          m_port;
+     CPortLatencyHWBase  *  m_io;
+     uint32_t               m_flag;
+
+};
+
+
+class CLatencyPktMode {
+ public:
+    uint8_t m_submode;
+    CLatencyPktMode(uint8_t submode) {m_submode = submode;}
+    virtual uint8_t getPacketLen() = 0;
+    virtual const uint8_t *getPacketData() = 0;
+    virtual void rcv_debug_print(uint8_t *pkt) = 0;
+    virtual void send_debug_print(uint8_t *pkt) = 0;
+    virtual void update_pkt(uint8_t *pkt, bool is_client_to_server, uint16_t l4_len, uint16_t *tx_seq) = 0;
+    virtual bool IsLatencyPkt(IPHeader *ip) = 0;
+    uint8_t l4_header_len() {return 8;}
+    virtual void update_recv(uint8_t *pkt, uint16_t *r_seq, uint16_t *t_seq) = 0;
+    virtual uint8_t getProtocol() = 0;
+    virtual ~CLatencyPktMode() {}
+};
+
+class CLatencyPktModeICMP: public CLatencyPktMode {
+ public:
+    CLatencyPktModeICMP(uint8_t submode) : CLatencyPktMode(submode) {}
+    uint8_t getPacketLen();
+    const uint8_t *getPacketData();
+    void rcv_debug_print(uint8_t *);
+    void send_debug_print(uint8_t *);
+    void update_pkt(uint8_t *pkt, bool is_client_to_server, uint16_t l4_len, uint16_t *tx_seq);
+    bool IsLatencyPkt(IPHeader *ip);
+    void update_recv(uint8_t *pkt, uint16_t *r_seq, uint16_t *t_seq);
+    uint8_t getProtocol() {return 0x1;}
+};
+
+class CLatencyPktModeSCTP: public CLatencyPktMode {
+ public:
+    CLatencyPktModeSCTP(uint8_t submode) : CLatencyPktMode(submode) {}
+    uint8_t getPacketLen();
+    const uint8_t *getPacketData();
+    void rcv_debug_print(uint8_t *);
+    void send_debug_print(uint8_t *);
+    void update_pkt(uint8_t *pkt, bool is_client_to_server, uint16_t l4_len, uint16_t *tx_seq);
+    bool IsLatencyPkt(IPHeader *ip);
+    void update_recv(uint8_t *pkt, uint16_t *r_seq, uint16_t *t_seq);
+    uint8_t getProtocol() {return 0x84;}
+};
+
+class CLatencyManager {
+public:
+    bool Create(CLatencyManagerCfg * cfg);
+    void Delete();
+    void  reset();
+    void  start(int iter);
+    void  stop();
+    bool  is_active();
+    void set_ip(uint32_t client_ip,
+                uint32_t server_ip,
+                uint32_t mask_dual_port){
+        m_pkt_gen.set_ip(client_ip,server_ip,mask_dual_port);
+    }
+    void Dump(FILE *fd); // dump all
+    void DumpShort(FILE *fd); // dump short histogram of latency 
+
+    void DumpRxCheck(FILE *fd); // dump all
+    void DumpShortRxCheck(FILE *fd); // dump short histogram of latency 
+    void rx_check_dump_json(std::string & json);
+    uint16_t get_latency_header_offset(){
+        return ( m_pkt_gen.get_payload_offset() );
+    }
+    void update();
+    void dump_json(std::string & json ); // dump to json 
+    void dump_json_v2(std::string & json );
+    void DumpRxCheckVerification(FILE *fd,uint64_t total_tx_rx_check);
+    void set_mask(uint32_t mask){
+        m_port_mask=mask;
+    }
+    double get_max_latency(void);
+    double get_avr_latency(void);
+    bool   is_any_error();
+    uint64_t get_total_pkt();
+    uint64_t get_total_bytes();
+    CNatRxManager * get_nat_manager(){
+        return ( &m_nat_check_manager );
+    }
+    CLatencyPktMode *c_l_pkt_mode;
+
+private:
+    void  send_pkt_all_ports();
+    void  try_rx();
+    void  try_rx_queues();
+    void  run_rx_queue_msgs(uint8_t thread_id,
+                                             CNodeRing * r);
+	void  wait_for_rx_dump();
+    void  handle_rx_pkt(CLatencyManagerPerPort * lp,
+                        rte_mbuf_t * m);
+    /* messages handlers */
+    void handle_latency_pkt_msg(uint8_t thread_id,
+                               CGenNodeLatencyPktInfo * msg);
+
+     pqueue_t                m_p_queue; /* priorty queue */
+     bool                    m_is_active;
+     CLatencyPktInfo         m_pkt_gen;
+     CLatencyManagerPerPort  m_ports[MAX_LATENCY_PORTS];
+     uint64_t                m_d_time; // calc tick betwen sending 
+     double                  m_cps;
+     double                  m_delta_sec;
+     uint64_t                m_start_time; // calc tick betwen sending 
+     uint32_t                m_port_mask;
+     uint32_t                m_max_ports;
+     RxCheckManager 	     m_rx_check_manager;
+     CNatRxManager           m_nat_check_manager;
+     CCpuUtlDp               m_cpu_dp_u;
+     CCpuUtlCp               m_cpu_cp_u;
+     volatile bool           m_do_stop __rte_cache_aligned ;
+};
+
+#endif
+
diff --git a/src/main_dpdk.cpp b/src/main_dpdk.cpp
index 3e5418b9..8c9eb914 100755
--- a/src/main_dpdk.cpp
+++ b/src/main_dpdk.cpp
@@ -51,6 +51,7 @@ limitations under the License.
 #include <rte_mbuf.h>
 #include <rte_random.h>
 #include "bp_sim.h"
+#include "latency.h"
 #include "os_time.h"
 #include <common/arg/SimpleGlob.h>
 #include <common/arg/SimpleOpt.h>
@@ -77,6 +78,7 @@ extern "C" {
 #include "utl_term_io.h"
 #include "msg_manager.h"
 #include "platform_cfg.h"
+#include "latency.h"
 
 #include <internal_api/trex_platform_api.h>
 
@@ -118,13 +120,10 @@ static inline int get_is_latency_thread_enable(){
     return (CGlobalInfo::m_options.is_latency_enabled() ?1:0);
 }
 
-
-
 struct port_cfg_t;
 class  CPhyEthIF;
 class CPhyEthIFStats ;
 
-
 class CTRexExtendedDriverBase {
 public:
 
@@ -436,12 +435,6 @@ static inline int get_min_sample_rate(void){
     return ( get_ex_drv()->get_min_sample_rate());
 }
 
-
-
-
-
-
-
 #define MAX_DPDK_ARGS 40
 static CPlatformYamlInfo global_platform_cfg_info;
 static int global_dpdk_args_num ;
@@ -450,9 +443,6 @@ static char global_cores_str[100];
 static char global_prefix_str[100];
 static char global_loglevel_str[20];
 
-
-
-
 // cores =0==1,1*2,2,3,4,5,6
 // An enum for all the option types
 enum { OPT_HELP, 
@@ -487,6 +477,7 @@ enum { OPT_HELP,
     OPT_IPV6,
     OPT_LEARN,
     OPT_LEARN_VERIFY,
+    OPT_L_PKT_MODE,
     OPT_NO_FLOW_CONTROL,
     OPT_RX_CHECK_HOPS,
 	OPT_MAC_FILE,
@@ -499,9 +490,6 @@ enum { OPT_HELP,
 };
 
 
-
-      
-
 /* these are the argument types:
    SO_NONE --    no argument needed
    SO_REQ_SEP -- single required argument
@@ -549,6 +537,7 @@ static CSimpleOpt::SOption parser_options[] =
     { OPT_IPV6,       "--ipv6",       SO_NONE   },
     { OPT_LEARN, "--learn",       SO_NONE   },
     { OPT_LEARN_VERIFY, "--learn-verify",       SO_NONE   },
+    { OPT_L_PKT_MODE, "--l-pkt-mode",       SO_REQ_SEP   },
     { OPT_NO_FLOW_CONTROL, "--no-flow-control",       SO_NONE   },
     { OPT_VLAN,       "--vlan",       SO_NONE   },
     { OPT_MAC_FILE, "--mac", SO_REQ_SEP }, 
@@ -622,7 +611,11 @@ static int usage(){
     printf(" --learn                    : Work in NAT environments, learn the dynamic NAT translation and ALG  \n");
     printf(" --learn-verify             : Learn the translation, but intended for verification of the mechanism in cases that NAT does not exist \n");
     printf("  \n");
-    
+    printf(" --l-pkt-mode [0-3]         : Set mode for sending latency packets.\n");
+    printf("      0 (default)    send SCTP packets  \n");
+    printf("      1              Send ICMP request packets  \n");
+    printf("      2              Send ICMP requests from client side, and response from server side (for working with firewall) \n");
+    printf("      3              Send ICMP requests with sequence ID 0 from both sides \n");
     printf(" -v  [1-3]                  :  verbose mode ( works only on the debug image ! )  \n");
     printf("      1    show only stats  \n");
     printf("      2    run preview do not write to file  \n");
@@ -685,7 +678,7 @@ static int usage(){
     printf(" limitations under the License.                                           \n");
     printf(" \n");
     printf(" Open Source Components / Libraries \n");
-    printf(" DPDK       (BSD)         \n");
+    printf(" DPDK       (BSD)       \n");
     printf(" YAML-CPP   (BSD)       \n");
     printf(" JSONCPP    (MIT)       \n");
     printf(" \n");
@@ -696,6 +689,7 @@ static int usage(){
     printf(" User    : %s   \n",VERSION_USER);
     printf(" Date    : %s , %s \n",get_build_date(),get_build_time());
     printf(" Uuid    : %s    \n",VERSION_UIID);
+    printf(" Git SHA : %s    \n",VERSION_GIT_SHA);
     return (0);
 }
 
@@ -782,6 +776,11 @@ static int parse_options(int argc, char *argv[], CParserOption* po, bool first_t
                 po->preview.set_lean_and_verify_mode_enable(true);
                 break;
 
+            case OPT_L_PKT_MODE :
+                sscanf(args.OptionArg(),"%d", &tmp_data);
+                po->m_l_pkt_mode=(uint8_t)tmp_data;
+                break;
+
             case OPT_REAL_TIME  :
                 printf(" warning -r is deprecated, real time is not needed any more , it is the default \n");
                 po->preview.setRealTime(true);
@@ -1448,11 +1447,11 @@ void CPhyEthIF::configure(uint16_t nb_rx_queue,
 
 /*
 
-rx-queue 0 - default- all traffic no SCTP 
+rx-queue 0 - default- all traffic not goint to queue 1
              will be drop as queue is disable 
              
 
-rx-queue 1 - SCTP traffic will go to here  
+rx-queue 1 - Latency measurement packets will go here  
 
             pci_reg_write(IXGBE_L34T_IMIR(0),(1<<21));
 
@@ -1875,7 +1874,7 @@ public:
 
     bool process_rx_pkt(pkt_dir_t   dir,rte_mbuf_t * m);
 
-    virtual int update_mac_addr_from_global_cfg(pkt_dir_t       dir, rte_mbuf_t      *m);
+    virtual int update_mac_addr_from_global_cfg(pkt_dir_t       dir, uint8_t * p);
 
     virtual pkt_dir_t port_id_to_dir(uint8_t port_id);
 
@@ -1918,8 +1917,6 @@ public:
     virtual int send_node(CGenNode * node);
 };
 
-
-
 bool CCoreEthIF::Create(uint8_t             core_id,
                         uint16_t            tx_client_queue_id,
                         CPhyEthIF  *        tx_client_port, 
@@ -1939,54 +1936,6 @@ bool CCoreEthIF::Create(uint8_t             core_id,
     return (true);
 }
 
-bool CCoreEthIF::process_rx_pkt(pkt_dir_t   dir,
-                                rte_mbuf_t * m){
-
-    CSimplePacketParser parser(m);
-    if ( !parser.Parse()  ){
-        return false;
-    }
-    bool send=false;
-    if ( parser.IsLatencyPkt() ){
-        send=true;
-
-    }else{
-        if ( get_is_rx_filter_enable() ){
-            uint8_t max_ttl = 0xff - get_rx_check_hops();
-            uint8_t pkt_ttl = parser.getTTl();
-            if ( (pkt_ttl==max_ttl) || (pkt_ttl==(max_ttl-1) ) ) {
-               send=true;
-            }
-        }
-    }
-
-
-    if (send) {
-        CGenNodeLatencyPktInfo * node=(CGenNodeLatencyPktInfo * )CGlobalInfo::create_node();
-        if ( node ) {
-            node->m_msg_type = CGenNodeMsgBase::LATENCY_PKT;
-            node->m_dir      = dir;
-            node->m_latency_offset = 0xdead;
-            node->m_pkt      = m;
-            if ( m_ring_to_rx->Enqueue((CGenNode*)node)==0 ){
-            }else{
-                CGlobalInfo::free_node((CGenNode *)node);
-                send=false;
-            }
-
-            #ifdef LATENCY_QUEUE_TRACE_
-            printf("rx to cp --\n");
-            rte_pktmbuf_dump(stdout,m, rte_pktmbuf_pkt_len(m));
-            #endif
-        }else{
-            send=false;
-        }
-    }
-   return (send);
-}
-
-
-
 void CCoreEthIF::flush_rx_queue(void){
     pkt_dir_t   dir ;
     bool is_latency=get_is_latency_thread_enable();
@@ -2020,7 +1969,6 @@ void CCoreEthIF::flush_rx_queue(void){
     }
 }
 
-
 int CCoreEthIF::flush_tx_queue(void){
     /* flush both sides */
     pkt_dir_t   dir ;
@@ -2040,7 +1988,6 @@ int CCoreEthIF::flush_tx_queue(void){
     return (0);
 }
 
-
 void CCoreEthIF::GetCoreCounters(CVirtualIFPerSideStats *stats){
     stats->Clear();
     pkt_dir_t   dir ;
@@ -2130,6 +2077,8 @@ int CCoreEthIF::send_pkt(CCorePerPort * lp_port,
                          CVirtualIFPerSideStats  * lp_stats
                          ){
 
+    //rte_pktmbuf_dump(stdout,m, rte_pktmbuf_pkt_len(m));
+
     lp_stats->m_tx_pkt   +=1;
     lp_stats->m_tx_bytes += (rte_pktmbuf_pkt_len(m)+4);
 
@@ -2186,12 +2135,18 @@ int CCoreEthIFStateless::send_node(CGenNode * no){
 
     /* check that we have mbuf  */
     rte_mbuf_t *    m=node_sl->get_cache_mbuf();
-    assert( m );
     pkt_dir_t dir=(pkt_dir_t)node_sl->get_mbuf_cache_dir();
     CCorePerPort *  lp_port=&m_ports[dir];
     CVirtualIFPerSideStats  * lp_stats = &m_stats[dir];
-    rte_pktmbuf_refcnt_update(m,1);
+    if (m) {
+        /* cache case */
+        rte_pktmbuf_refcnt_update(m,1);
+    }else{
+        m=node_sl->alloc_node_with_vm();
+        assert(m);
+    }
     send_pkt(lp_port,m,lp_stats);
+
     return (0);
 };
 
@@ -2290,14 +2245,12 @@ int CCoreEthIF::send_node(CGenNode * node){
 }
 
 
-int CCoreEthIF::update_mac_addr_from_global_cfg(pkt_dir_t  dir, 
-                                rte_mbuf_t      *m){
-    assert(m);
+int CCoreEthIF::update_mac_addr_from_global_cfg(pkt_dir_t  dir, uint8_t * p){
+    assert(p);
     assert(dir<2);
+
     CCorePerPort *  lp_port=&m_ports[dir];
-    uint8_t *p=rte_pktmbuf_mtod(m, uint8_t*);
     uint8_t p_id=lp_port->m_port->get_port_id();
-
     memcpy(p,CGlobalInfo::m_options.get_dst_src_mac_addr(p_id),12);
     return (0);
 }
@@ -2854,7 +2807,7 @@ private:
 
     int create_pkt(uint8_t *pkt,int pkt_size);
     int create_udp_pkt();
-    int create_sctp_pkt();
+    int create_icmp_pkt();
 
 
 
@@ -2972,7 +2925,6 @@ int CGlobalTRex::test_send(){
     int i;
 
     //set_promisc_all(true);
-    //create_sctp_pkt();
     create_udp_pkt();
 
 	CRx_check_header rx_check_header;
@@ -2995,18 +2947,7 @@ int CGlobalTRex::test_send(){
         //test_send_pkts(m_latency_tx_queue_id,1,2);
         //test_send_pkts(m_latency_tx_queue_id,1,3);
         test_send_pkts(0,1,0);
-		test_send_pkts(0,1,1);
-        //test_send_pkts(2,1,0);
-
-
-        //test_send_pkts(0,1,1);
-        //test_send_pkts(0,1,2);
-        //test_send_pkts(0,1,3);
-
-        /*test_send_pkts(2,1,0);
-        test_send_pkts(2,1,1);
-        test_send_pkts(2,1,2);
-        test_send_pkts(2,1,3);*/
+        test_send_pkts(0,2,1);
 
         /*delay(1000);
         fprintf(stdout," --------------------------------\n");
@@ -3091,22 +3032,21 @@ const uint8_t udp_pkt[]={
 };
 
 
-const uint8_t sctp_pkt1[]={ 
-
+const uint8_t icmp_pkt1[]={
     0x00,0x00,0x00,0x01,0x00,0x00,
     0x00,0x00,0x00,0x01,0x00,0x00,
     0x08,0x00,
 
     0x45,0x02,0x00,0x30,
     0x00,0x00,0x40,0x00,
-    0x40,0x84,0xbd,0x04,
-    0x01,0x01,0x01,0x01, //sIP
-    0x02,0x02,0x02,0x02, //DIP
-
-    0x80,0x44,//SPORT
-    0x00,0x50,//DPORT
+    0xaa,0x01,0xbd,0x04,
+    0x9b,0xe6,0x18,0x9b, //SIP
+    0xcb,0xff,0xfc,0xc2, //DIP
 
-    0x00,0x00,0x00,0x00, //checksum 
+    0x08, 0x00, 
+    0x01, 0x02,  //checksum
+    0xaa, 0xbb,  // id
+    0x00, 0x00,  // Sequence number
 
     0x11,0x22,0x33,0x44, // magic 
     0x00,0x00,0x00,0x00, //64 bit counter
@@ -3114,8 +3054,7 @@ const uint8_t sctp_pkt1[]={
     0x00,0x01,0xa0,0x00, //seq
     0x00,0x00,0x00,0x00,
 
-};
-
+}; 
 
 
 
@@ -3144,8 +3083,8 @@ int CGlobalTRex::create_udp_pkt(){
     return (create_pkt((uint8_t*)udp_pkt,sizeof(udp_pkt)));
 }
 
-int CGlobalTRex::create_sctp_pkt(){
-    return (create_pkt((uint8_t*)sctp_pkt1,sizeof(sctp_pkt1)));
+int CGlobalTRex::create_icmp_pkt(){
+    return (create_pkt((uint8_t*)icmp_pkt1,sizeof(icmp_pkt1)));
 }
 
 
@@ -3392,7 +3331,7 @@ int  CGlobalTRex::ixgbe_start(void){
                           m_cores_to_dual_ports+1,
                           &m_port_cfg.m_port_conf);
 
-            /* the latency queue for SCTP */
+            /* the latency queue for latency measurement packets */
             m_latency_tx_queue_id= m_cores_to_dual_ports;
 
             socket_id_t socket_id = CGlobalInfo::m_socket.port_to_socket((port_id_t)i);
@@ -3409,7 +3348,7 @@ int  CGlobalTRex::ixgbe_start(void){
 
             /* set the filter queue */
             _if->set_rx_queue(1);
-            /* sctp ring is 1 */
+            /* latency measurement ring is 1 */
             _if->rx_queue_setup(1,
                                 RTE_TEST_RX_LATENCY_DESC_DEFAULT,
                                 socket_id, 
@@ -4110,13 +4049,15 @@ int CGlobalTRex::run_in_master(){
                     break;
                 }
 
-                m_mg.rx_check_dump_json(json );
-                m_zmq_publisher.publish_json(json);
-
               }/* ex checked */
 
             }
 
+            if ( get_is_rx_check_mode() ) {
+                m_mg.rx_check_dump_json(json );
+                m_zmq_publisher.publish_json(json);
+            }
+
             /* backward compatible */
             m_mg.dump_json(json );
             m_zmq_publisher.publish_json(json);
@@ -4351,6 +4292,54 @@ int CGlobalTRex::start_send_master(){
 
 static CGlobalTRex g_trex;
 
+bool CCoreEthIF::process_rx_pkt(pkt_dir_t   dir,
+                                rte_mbuf_t * m){
+
+    CSimplePacketParser parser(m);
+    if ( !parser.Parse()  ){
+        return false;
+    }
+    bool send=false;
+    CLatencyPktMode *c_l_pkt_mode = g_trex.m_mg.c_l_pkt_mode;
+    bool is_lateancy_pkt =  c_l_pkt_mode->IsLatencyPkt(parser.m_ipv4) & parser.IsLatencyPkt(parser.m_l4 + c_l_pkt_mode->l4_header_len());
+
+    if (is_lateancy_pkt){
+        send=true;
+    }else{
+        if ( get_is_rx_filter_enable() ){
+            uint8_t max_ttl = 0xff - get_rx_check_hops();
+            uint8_t pkt_ttl = parser.getTTl();
+            if ( (pkt_ttl==max_ttl) || (pkt_ttl==(max_ttl-1) ) ) {
+               send=true;
+            }
+        }
+    }
+
+
+    if (send) {
+        CGenNodeLatencyPktInfo * node=(CGenNodeLatencyPktInfo * )CGlobalInfo::create_node();
+        if ( node ) {
+            node->m_msg_type = CGenNodeMsgBase::LATENCY_PKT;
+            node->m_dir      = dir;
+            node->m_latency_offset = 0xdead;
+            node->m_pkt      = m;
+            if ( m_ring_to_rx->Enqueue((CGenNode*)node)==0 ){
+            }else{
+                CGlobalInfo::free_node((CGenNode *)node);
+                send=false;
+            }
+
+            #ifdef LATENCY_QUEUE_TRACE_
+            printf("rx to cp --\n");
+            rte_pktmbuf_dump(stdout,m, rte_pktmbuf_pkt_len(m));
+            #endif
+        }else{
+            send=false;
+        }
+    }
+   return (send);
+}
+
 
 TrexStateless * get_stateless_obj() {
     return g_trex.m_trex_stateless;
@@ -4476,8 +4465,7 @@ int update_global_info_from_platform_file(){
 
     CGlobalInfo::m_memory_cfg.set(cg->m_memory,mul);
     CGlobalInfo::m_memory_cfg.set_number_of_dp_cors(
-        CGlobalInfo::m_options.get_number_of_dp_cores_needed() );
-
+    CGlobalInfo::m_options.get_number_of_dp_cores_needed() );
     return (0);
 }
 
@@ -4736,15 +4724,19 @@ int CTRexExtendedDriverBase1G::wait_for_stable_link(){
 }
 
 int CTRexExtendedDriverBase1G::configure_drop_queue(CPhyEthIF * _if){
+    uint8_t protocol;
+    if (CGlobalInfo::m_options.m_l_pkt_mode == 0) {
+        protocol = IPPROTO_SCTP;
+    } else {
+        protocol = IPPROTO_ICMP;
+    }
+
     _if->pci_reg_write( E1000_RXDCTL(0) , 0);
 
     /* enable filter to pass packet to rx queue 1 */
-
     _if->pci_reg_write( E1000_IMIR(0), 0x00020000);
-
     _if->pci_reg_write( E1000_IMIREXT(0), 0x00081000);
-
-    _if->pci_reg_write( E1000_TTQF(0),   0x00000084 /* protocol */
+    _if->pci_reg_write( E1000_TTQF(0),   protocol
                                   | 0x00008100 /* enable */
                                   | 0xE0010000 /* RX queue is 1 */
                                     );
@@ -4772,11 +4764,13 @@ int CTRexExtendedDriverBase1G::configure_rx_filter_rules(CPhyEthIF * _if){
         */
         int i;
         // IPv4: bytes being compared are {TTL, Protocol}
-        uint16_t ff_rules_v4[4]={
+        uint16_t ff_rules_v4[6]={
             (uint16_t)(0xFF06 - v4_hops),
             (uint16_t)(0xFE11 - v4_hops),
             (uint16_t)(0xFF11 - v4_hops),
             (uint16_t)(0xFE06 - v4_hops),
+            (uint16_t)(0xFF01 - v4_hops),
+            (uint16_t)(0xFE01 - v4_hops),
         }  ;
         // IPv6: bytes being compared are {NextHdr, HopLimit}
         uint16_t ff_rules_v6[2]={
@@ -4917,24 +4911,30 @@ int CTRexExtendedDriverBase10G::configure_rx_filter_rules(CPhyEthIF * _if){
 
 
         // IPv4: bytes being compared are {TTL, Protocol}
-        uint16_t ff_rules_v4[4]={
+        uint16_t ff_rules_v4[6]={
             (uint16_t)(0xFF11 - v4_hops),
             (uint16_t)(0xFE11 - v4_hops),
             (uint16_t)(0xFF06 - v4_hops),
             (uint16_t)(0xFE06 - v4_hops),
+            (uint16_t)(0xFF01 - v4_hops),
+            (uint16_t)(0xFE01 - v4_hops),
         }  ;
         // IPv6: bytes being compared are {NextHdr, HopLimit}
-        uint16_t ff_rules_v6[4]={
+        uint16_t ff_rules_v6[6]={
+            (uint16_t)(0x3CFF - hops),
+            (uint16_t)(0x3CFE - hops),
             (uint16_t)(0x3CFF - hops),
             (uint16_t)(0x3CFE - hops),
             (uint16_t)(0x3CFF - hops),
             (uint16_t)(0x3CFE - hops),
         }  ;
-        const rte_l4type ff_rules_type[4]={
+        const rte_l4type ff_rules_type[6]={
             RTE_FDIR_L4TYPE_UDP,
             RTE_FDIR_L4TYPE_UDP,
             RTE_FDIR_L4TYPE_TCP,
-            RTE_FDIR_L4TYPE_TCP
+            RTE_FDIR_L4TYPE_TCP,
+            RTE_FDIR_L4TYPE_NONE,
+            RTE_FDIR_L4TYPE_NONE
         }  ;
 
         uint16_t *ff_rules;
@@ -4974,8 +4974,7 @@ int CTRexExtendedDriverBase10G::configure_rx_filter_rules(CPhyEthIF * _if){
 }
 
 int CTRexExtendedDriverBase10G::configure_drop_queue(CPhyEthIF * _if){
-
-        /* enable rule 0 SCTP -> queue 1 for latency  */
+    /* enable rule 0 SCTP -> queue 1 for latency  */
     /* 1<<21 means that queue 1 is for SCTP */
     _if->pci_reg_write(IXGBE_L34T_IMIR(0),(1<<21));
 
@@ -4985,7 +4984,6 @@ int CTRexExtendedDriverBase10G::configure_drop_queue(CPhyEthIF * _if){
                       ((0x0f)<<IXGBE_FTQF_5TUPLE_MASK_SHIFT)|IXGBE_FTQF_QUEUE_ENABLE);
 
     /* disable queue zero - default all traffic will go to here and will be dropped */
-
     _if->pci_reg_write( IXGBE_RXDCTL(0) , 0);
     return (0);
 }
@@ -5046,7 +5044,7 @@ void CTRexExtendedDriverBase40G::update_configuration(port_cfg_t * cfg){
 }
 
 
-
+/* Add rule to send packets with protocol 'type', and ttl 'ttl' to rx queue 1 */
 void CTRexExtendedDriverBase40G::add_rules(CPhyEthIF * _if,
                                            enum rte_eth_flow_type type,
                                            uint8_t ttl){
@@ -5071,7 +5069,11 @@ void CTRexExtendedDriverBase40G::add_rules(CPhyEthIF * _if,
     filter.input.flow_type = type;
     filter.input.ttl=ttl;
 
-    /* any SCTP move to queue number 1 */
+    if (type == RTE_ETH_FLOW_TYPE_IPV4_OTHER) {
+        filter.input.flow.ip4_flow.l4_proto = IPPROTO_ICMP; // In this case we want filter for icmp packets
+    }
+
+    /* We want to place latency packets in queue 1 */
     ret=rte_eth_dev_filter_ctrl(port_id, RTE_ETH_FILTER_FDIR,
                 RTE_ETH_FILTER_ADD, (void*)&filter);
 
@@ -5100,7 +5102,9 @@ int CTRexExtendedDriverBase40G::configure_rx_filter_rules(CPhyEthIF * _if){
 
 int CTRexExtendedDriverBase40G::configure_drop_queue(CPhyEthIF * _if){
 
-    add_rules(_if,RTE_ETH_FLOW_TYPE_SCTPV4,0);
+    /* Configure queue for latency packets */
+    add_rules(_if,RTE_ETH_FLOW_TYPE_IPV4_OTHER,255);
+    add_rules(_if,RTE_ETH_FLOW_TYPE_SCTPV4,255);
     return (0);
 }
 
diff --git a/src/platform_cfg.cpp b/src/platform_cfg.cpp
index 547cc3ad..ca42aa31 100755
--- a/src/platform_cfg.cpp
+++ b/src/platform_cfg.cpp
@@ -35,8 +35,8 @@ void CPlatformMemoryYamlInfo::reset(){
        m_mbuf[MBUF_64]           = m_mbuf[MBUF_64]*2;
        m_mbuf[MBUF_2048]         = CONST_NB_MBUF_2_10G/2;
 
-       m_mbuf[TRAFFIC_MBUF_64]           = m_mbuf[MBUF_64]*2;
-       m_mbuf[TRAFFIC_MBUF_2048]         = CONST_NB_MBUF_2_10G*4;
+       m_mbuf[TRAFFIC_MBUF_64]           = m_mbuf[MBUF_64] * 4;
+       m_mbuf[TRAFFIC_MBUF_2048]         = CONST_NB_MBUF_2_10G * 8;
 
        m_mbuf[MBUF_DP_FLOWS]     = (1024*1024/2);
        m_mbuf[MBUF_GLOBAL_FLOWS] =(10*1024/2);
diff --git a/src/publisher/trex_publisher.h b/src/publisher/trex_publisher.h
index 8d1be064..bd4392f7 100644
--- a/src/publisher/trex_publisher.h
+++ b/src/publisher/trex_publisher.h
@@ -39,10 +39,16 @@ public:
     void publish_json(const std::string &s);
 
     enum event_type_e {
-        EVENT_PORT_STARTED       = 0,
-        EVENT_PORT_STOPPED       = 1,
-        EVENT_SERVER_STOPPED     = 2,
-        EVENT_PORT_FINISHED_TX   = 3,
+        EVENT_PORT_STARTED          = 0,
+        EVENT_PORT_STOPPED          = 1,
+        EVENT_PORT_PAUSED           = 2,
+        EVENT_PORT_RESUMED          = 3,
+        EVENT_PORT_FINISHED_TX      = 4,
+        EVENT_PORT_FORCE_ACQUIRED   = 5,
+
+        EVENT_SERVER_STOPPED        = 100,
+        
+        
     };
 
     void publish_event(event_type_e type, const Json::Value &data = Json::nullValue);
diff --git a/src/rpc-server/commands/trex_rpc_cmd_general.cpp b/src/rpc-server/commands/trex_rpc_cmd_general.cpp
index 9570aae7..a701f6db 100644
--- a/src/rpc-server/commands/trex_rpc_cmd_general.cpp
+++ b/src/rpc-server/commands/trex_rpc_cmd_general.cpp
@@ -43,7 +43,7 @@ using namespace std;
 trex_rpc_cmd_rc_e 
 TrexRpcCmdPing::_run(const Json::Value &params, Json::Value &result) {
 
-    result["result"] = "ACK";
+    result["result"] = Json::objectValue;
     return (TREX_RPC_CMD_OK);
 }
 
@@ -198,10 +198,6 @@ TrexRpcCmdGetSysInfo::_run(const Json::Value &params, Json::Value &result) {
         }
 
 
-        section["ports"][i]["owner"] = port->get_owner();
-
-        section["ports"][i]["status"] = port->get_state_as_string();
-
     }
 
     return (TREX_RPC_CMD_OK);
@@ -224,7 +220,7 @@ TrexRpcCmdGetOwner::_run(const Json::Value &params, Json::Value &result) {
     uint8_t port_id = parse_port(params, result);
 
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
-    section["owner"] = port->get_owner();
+    section["owner"] = port->get_owner().get_name();
 
     return (TREX_RPC_CMD_OK);
 }
@@ -238,19 +234,20 @@ TrexRpcCmdAcquire::_run(const Json::Value &params, Json::Value &result) {
 
     uint8_t port_id = parse_port(params, result);
 
-    const string &new_owner = parse_string(params, "user", result);
+    const string  &new_owner  = parse_string(params, "user", result);
     bool force = parse_bool(params, "force", result);
+    uint32_t session_id = parse_uint32(params, "session_id", result);
 
     /* if not free and not you and not force - fail */
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
     try {
-        port->acquire(new_owner, force);
+        port->acquire(new_owner, session_id, force);
     } catch (const TrexRpcException &ex) {
         generate_execute_err(result, ex.what());
     }
 
-    result["result"] = port->get_owner_handler();
+    result["result"] = port->get_owner().get_handler();
 
     return (TREX_RPC_CMD_OK);
 }
@@ -272,7 +269,7 @@ TrexRpcCmdRelease::_run(const Json::Value &params, Json::Value &result) {
         generate_execute_err(result, ex.what());
     }
 
-    result["result"] = "ACK";
+    result["result"] = Json::objectValue;
 
     return (TREX_RPC_CMD_OK);
 }
@@ -288,8 +285,6 @@ TrexRpcCmdGetPortStats::_run(const Json::Value &params, Json::Value &result) {
 
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
-    result["result"]["status"] = port->get_state_as_string();
-
     try {
         port->encode_stats(result["result"]);
     } catch (const TrexRpcException &ex) {
@@ -300,41 +295,25 @@ TrexRpcCmdGetPortStats::_run(const Json::Value &params, Json::Value &result) {
 }
 
 /**
- * request the server a sync about a specific user
+ * fetch the port status
+ * 
+ * @author imarom (09-Dec-15)
+ * 
+ * @param params 
+ * @param result 
  * 
+ * @return trex_rpc_cmd_rc_e 
  */
 trex_rpc_cmd_rc_e
-TrexRpcCmdSyncUser::_run(const Json::Value &params, Json::Value &result) {
-
-    const string &user = parse_string(params, "user", result);
-    bool sync_streams = parse_bool(params, "sync_streams", result);
-
-    result["result"] = Json::arrayValue;
-
-    for (auto port : get_stateless_obj()->get_port_list()) {
-        if (port->get_owner() == user) {
-
-            Json::Value owned_port;
+TrexRpcCmdGetPortStatus::_run(const Json::Value &params, Json::Value &result) {
+    uint8_t port_id = parse_port(params, result);
 
-            owned_port["port_id"] = port->get_port_id();
-            owned_port["handler"] = port->get_owner_handler();
-            owned_port["state"]   = port->get_state_as_string();
-            
-            /* if sync streams was asked - sync all the streams */
-            if (sync_streams) {
-                owned_port["streams"] = Json::arrayValue;
+    TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
-                std::vector <TrexStream *> streams;
-                port->get_object_list(streams);
+    result["result"]["owner"]  = (port->get_owner().is_free() ? "" : port->get_owner().get_name());
+    result["result"]["state"] = port->get_state_as_string();
 
-                for (auto stream : streams) {
-                    owned_port["streams"].append(stream->get_stream_json());
-                }
-            }
-
-            result["result"].append(owned_port);
-        }
-    }
 
     return (TREX_RPC_CMD_OK);
 }
+
diff --git a/src/rpc-server/commands/trex_rpc_cmd_stream.cpp b/src/rpc-server/commands/trex_rpc_cmd_stream.cpp
index 96224d4e..d8f7e772 100644
--- a/src/rpc-server/commands/trex_rpc_cmd_stream.cpp
+++ b/src/rpc-server/commands/trex_rpc_cmd_stream.cpp
@@ -23,27 +23,12 @@ limitations under the License.
 #include <trex_stream.h>
 #include <trex_stateless.h>
 #include <trex_stateless_port.h>
+#include <trex_streams_compiler.h>
 
 #include <iostream>
 
 using namespace std;
 
-/**
- * simple parser of string to number 
- * only difference is that it enforces whole number 
- * and not partial 
- * 
- */
-static uint64_t str2num(const string &str) {
-    size_t index;
-
-    uint64_t num = std::stoull(str, &index, 0);
-    if (index != str.size()) {
-        throw invalid_argument("could not parse string to number");
-    }
-
-    return (num);
-}
 
 /***************************
  * add new stream
@@ -52,7 +37,8 @@ static uint64_t str2num(const string &str) {
 trex_rpc_cmd_rc_e
 TrexRpcCmdAddStream::_run(const Json::Value &params, Json::Value &result) {
 
-    uint8_t  port_id    = parse_int(params, "port_id", result);
+    uint8_t port_id = parse_port(params, result);
+
     uint32_t stream_id  = parse_int(params, "stream_id", result);
 
     const Json::Value &section = parse_object(params, "stream", result);
@@ -122,7 +108,7 @@ TrexRpcCmdAddStream::_run(const Json::Value &params, Json::Value &result) {
         generate_execute_err(result, ex.what());
     }
 
-    result["result"] = "ACK";
+    result["result"] = Json::objectValue;
 
     return (TREX_RPC_CMD_OK);
 }
@@ -190,6 +176,30 @@ TrexRpcCmdAddStream::parse_vm_instr_checksum(const Json::Value &inst, TrexStream
 }
 
 void 
+TrexRpcCmdAddStream::parse_vm_instr_tuple_flow_var(const Json::Value &inst, TrexStream *stream, Json::Value &result){
+
+
+    std::string  flow_var_name = parse_string(inst, "name", result);
+
+    uint32_t ip_min       = parse_uint32(inst, "ip_min", result);
+    uint32_t ip_max       = parse_uint32(inst, "ip_max", result);
+    uint16_t port_min     = parse_uint16(inst, "port_min", result);
+    uint16_t port_max     = parse_uint16(inst, "port_max", result);
+    uint32_t limit_flows  = parse_uint32(inst, "limit_flows", result);
+    uint16_t flags        = parse_uint16(inst, "flags", result);
+
+    stream->m_vm.add_instruction(new StreamVmInstructionFlowClient(flow_var_name,
+                                                                ip_min,
+                                                                ip_max,
+                                                                port_min,
+                                                                port_max,
+                                                                limit_flows,
+                                                                flags
+                                                                ));
+}
+
+
+void 
 TrexRpcCmdAddStream::parse_vm_instr_flow_var(const Json::Value &inst, TrexStream *stream, Json::Value &result) {
     std::string  flow_var_name = parse_string(inst, "name", result);
 
@@ -211,31 +221,9 @@ TrexRpcCmdAddStream::parse_vm_instr_flow_var(const Json::Value &inst, TrexStream
         throw TrexRpcException("internal error");
     }
 
-    std::string  init_value_str    = parse_string(inst, "init_value", result);
-    std::string  min_value_str     = parse_string(inst, "min_value", result);
-    std::string  max_value_str     = parse_string(inst, "max_value", result);
-
-    uint64_t init_value = 0;
-    uint64_t min_value = 0;
-    uint64_t max_value = 0;
-
-    try {
-        init_value = str2num(init_value_str);
-    } catch (invalid_argument) {
-        generate_parse_err(result, "failed to parse 'init_value' as a number");
-    }
-
-    try {
-        min_value = str2num(min_value_str);
-    } catch (invalid_argument) {
-        generate_parse_err(result, "failed to parse 'min_value' as a number");
-    }
-
-    try {
-        max_value = str2num(max_value_str);
-    } catch (invalid_argument) {
-        generate_parse_err(result, "failed to parse 'max_value' as a number");
-    }
+    uint64_t init_value  = parse_uint64(inst, "init_value", result);
+    uint64_t min_value   = parse_uint64(inst, "min_value", result);
+    uint64_t max_value   = parse_uint64(inst, "max_value", result);
 
     stream->m_vm.add_instruction(new StreamVmInstructionFlowMan(flow_var_name,
                                                                 flow_var_size,
@@ -263,9 +251,9 @@ void
 TrexRpcCmdAddStream::parse_vm(const Json::Value &vm, TrexStream *stream, Json::Value &result) {
     /* array of VM instructions on vm */
     for (int i = 0; i < vm.size(); i++) {
-        const Json::Value & inst = vm[i];
+        const Json::Value & inst = parse_object(vm, i, result);
 
-        auto vm_types = {"fix_checksum_ipv4", "flow_var", "write_flow_var"};
+        auto vm_types = {"fix_checksum_ipv4", "flow_var", "write_flow_var","tuple_flow_var"};
         std::string vm_type = parse_choice(inst, "type", vm_types, result);
 
         // checksum instruction
@@ -278,6 +266,8 @@ TrexRpcCmdAddStream::parse_vm(const Json::Value &vm, TrexStream *stream, Json::V
         } else if (vm_type == "write_flow_var") {
             parse_vm_instr_write_flow_var(inst, stream, result);
 
+        } else if (vm_type == "tuple_flow_var") {
+            parse_vm_instr_tuple_flow_var(inst, stream, result);
         } else {
             /* internal error */
             throw TrexRpcException("internal error");
@@ -296,15 +286,7 @@ TrexRpcCmdAddStream::validate_stream(const TrexStream *stream, Json::Value &resu
         generate_execute_err(result, ss.str()); 
     }
 
-    /* port id should be between 0 and count - 1 */
-    if (stream->m_port_id >= get_stateless_obj()->get_port_count()) {
-        std::stringstream ss;
-        ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
-        delete stream;
-        generate_execute_err(result, ss.str());
-    }
-
-     /* add the stream to the port's stream table */
+    /* add the stream to the port's stream table */
     TrexStatelessPort * port = get_stateless_obj()->get_port_by_id(stream->m_port_id);
 
     /* does such a stream exists ? */
@@ -323,17 +305,11 @@ TrexRpcCmdAddStream::validate_stream(const TrexStream *stream, Json::Value &resu
  **************************/
 trex_rpc_cmd_rc_e
 TrexRpcCmdRemoveStream::_run(const Json::Value &params, Json::Value &result) {
-    uint8_t  port_id = parse_byte(params, "port_id", result);
-    uint32_t stream_id = parse_int(params, "stream_id", result);
-
-
-    if (port_id >= get_stateless_obj()->get_port_count()) {
-        std::stringstream ss;
-        ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
-        generate_execute_err(result, ss.str());
-    }
 
+    uint8_t port_id = parse_port(params, result);
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
+
+    uint32_t stream_id = parse_int(params, "stream_id", result);
     TrexStream *stream = port->get_stream_by_id(stream_id);
 
     if (!stream) {
@@ -350,7 +326,7 @@ TrexRpcCmdRemoveStream::_run(const Json::Value &params, Json::Value &result) {
     
     delete stream;
 
-    result["result"] = "ACK";
+    result["result"] = Json::objectValue;
 
     return (TREX_RPC_CMD_OK);
 }
@@ -362,14 +338,8 @@ TrexRpcCmdRemoveStream::_run(const Json::Value &params, Json::Value &result) {
  **************************/
 trex_rpc_cmd_rc_e
 TrexRpcCmdRemoveAllStreams::_run(const Json::Value &params, Json::Value &result) {
-    uint8_t  port_id = parse_byte(params, "port_id", result);
-
-    if (port_id >= get_stateless_obj()->get_port_count()) {
-        std::stringstream ss;
-        ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
-        generate_execute_err(result, ss.str());
-    }
 
+    uint8_t port_id = parse_port(params, result);
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
     try {
@@ -379,7 +349,7 @@ TrexRpcCmdRemoveAllStreams::_run(const Json::Value &params, Json::Value &result)
     }
 
 
-    result["result"] = "ACK";
+    result["result"] = Json::objectValue;
 
     return (TREX_RPC_CMD_OK);
 }
@@ -393,27 +363,20 @@ trex_rpc_cmd_rc_e
 TrexRpcCmdGetStreamList::_run(const Json::Value &params, Json::Value &result) {
     std::vector<uint32_t> stream_list;
 
-    uint8_t  port_id = parse_byte(params, "port_id", result);
-
-    if (port_id >= get_stateless_obj()->get_port_count()) {
-        std::stringstream ss;
-        ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
-        generate_execute_err(result, ss.str());
-    }
-
-       TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
+    uint8_t port_id = parse_port(params, result);
+    TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
-       port->get_id_list(stream_list);
+    port->get_id_list(stream_list);
 
-       Json::Value json_list = Json::arrayValue;
+    Json::Value json_list = Json::arrayValue;
 
-       for (auto stream_id : stream_list) {
-           json_list.append(stream_id);
-       }
+    for (auto stream_id : stream_list) {
+        json_list.append(stream_id);
+    }
 
-       result["result"] = json_list;
+    result["result"] = json_list;
 
-       return (TREX_RPC_CMD_OK);
+    return (TREX_RPC_CMD_OK);
 }
 
 /***************************
@@ -423,18 +386,13 @@ TrexRpcCmdGetStreamList::_run(const Json::Value &params, Json::Value &result) {
  **************************/
 trex_rpc_cmd_rc_e
 TrexRpcCmdGetStream::_run(const Json::Value &params, Json::Value &result) {
-    uint8_t  port_id   = parse_byte(params, "port_id", result);
-    bool     get_pkt   = parse_bool(params, "get_pkt", result);
-    uint32_t stream_id = parse_int(params, "stream_id", result);
-
-    if (port_id >= get_stateless_obj()->get_port_count()) {
-        std::stringstream ss;
-        ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
-        generate_execute_err(result, ss.str());
-    }
 
+    uint8_t port_id = parse_port(params, result);
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
+    bool     get_pkt   = parse_bool(params, "get_pkt", result);
+    uint32_t stream_id = parse_int(params, "stream_id", result);
+
     TrexStream *stream = port->get_stream_by_id(stream_id);
 
     if (!stream) {
@@ -462,49 +420,32 @@ TrexRpcCmdGetStream::_run(const Json::Value &params, Json::Value &result) {
 trex_rpc_cmd_rc_e
 TrexRpcCmdStartTraffic::_run(const Json::Value &params, Json::Value &result) {
 
-    uint8_t port_id  = parse_byte(params, "port_id", result);
-    double duration  = parse_double(params, "duration", result);
-
-    if (port_id >= get_stateless_obj()->get_port_count()) {
-        std::stringstream ss;
-        ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
-        generate_execute_err(result, ss.str());
-    }
-
+    uint8_t port_id = parse_port(params, result);
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
+    double duration  = parse_double(params, "duration", result);
 
-    const Json::Value &mul = parse_object(params, "mul", result);
-
-    std::string mul_type = parse_string(mul, "type", result);
-    double max_rate = parse_double(mul, "max", result);
-
-
-    double m = 0;
-
-    /* dispatch according to type of multiplier  */
-    if (mul_type == "raw") {
-        m = max_rate;
-
-    } else if (mul_type == "max_bps") {
-        m = port->calculate_m_from_bps(max_rate);
+    /* multiplier */
+    const Json::Value &mul_obj  = parse_object(params, "mul", result);
 
-    } else if (mul_type == "max_pps") {
-        m = port->calculate_m_from_pps(max_rate);
+    std::string type   = parse_choice(mul_obj, "type", TrexPortMultiplier::g_types, result);
+    std::string op     = parse_string(mul_obj, "op", result);
+    double      value  = parse_double(mul_obj, "value", result);
 
-    } else {
-        generate_parse_err(result, "multiplier type can be either 'raw', 'max_bps' or 'max_pps'");
+    if (op != "abs") {
+        generate_parse_err(result, "start message can only specify absolute speed rate");
     }
 
+    TrexPortMultiplier mul(type, op, value);
 
     try {
-        port->start_traffic(m, duration);
+        port->start_traffic(mul, duration);
 
     } catch (const TrexRpcException &ex) {
         generate_execute_err(result, ex.what());
     }
 
-    result["result"] = "ACK";
+    result["result"]["multiplier"] = port->get_multiplier();
 
     return (TREX_RPC_CMD_OK);
 }
@@ -515,14 +456,8 @@ TrexRpcCmdStartTraffic::_run(const Json::Value &params, Json::Value &result) {
  **************************/
 trex_rpc_cmd_rc_e
 TrexRpcCmdStopTraffic::_run(const Json::Value &params, Json::Value &result) {
-    uint8_t  port_id = parse_byte(params, "port_id", result);
-
-    if (port_id >= get_stateless_obj()->get_port_count()) {
-        std::stringstream ss;
-        ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
-        generate_execute_err(result, ss.str());
-    }
 
+    uint8_t port_id = parse_port(params, result);
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
     try {
@@ -531,7 +466,7 @@ TrexRpcCmdStopTraffic::_run(const Json::Value &params, Json::Value &result) {
         generate_execute_err(result, ex.what());
     }
 
-    result["result"] = "ACK";
+    result["result"] = Json::objectValue;
 
     return (TREX_RPC_CMD_OK);
 }
@@ -542,17 +477,12 @@ TrexRpcCmdStopTraffic::_run(const Json::Value &params, Json::Value &result) {
  **************************/
 trex_rpc_cmd_rc_e
 TrexRpcCmdGetAllStreams::_run(const Json::Value &params, Json::Value &result) {
-    uint8_t port_id = parse_byte(params, "port_id", result);
-    bool    get_pkt = parse_bool(params, "get_pkt", result);
-     
-    if (port_id >= get_stateless_obj()->get_port_count()) {
-        std::stringstream ss;
-        ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
-        generate_execute_err(result, ss.str());
-    }
-
+    
+    uint8_t port_id = parse_port(params, result);
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
+    bool    get_pkt = parse_bool(params, "get_pkt", result);
+
     std::vector <TrexStream *> streams;
     port->get_object_list(streams);
 
@@ -584,14 +514,7 @@ TrexRpcCmdGetAllStreams::_run(const Json::Value &params, Json::Value &result) {
 trex_rpc_cmd_rc_e
 TrexRpcCmdPauseTraffic::_run(const Json::Value &params, Json::Value &result) {
 
-    uint8_t port_id = parse_byte(params, "port_id", result);
-
-    if (port_id >= get_stateless_obj()->get_port_count()) {
-        std::stringstream ss;
-        ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
-        generate_execute_err(result, ss.str());
-    }
-
+    uint8_t port_id = parse_port(params, result);
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
      try {
@@ -600,7 +523,7 @@ TrexRpcCmdPauseTraffic::_run(const Json::Value &params, Json::Value &result) {
         generate_execute_err(result, ex.what());
     }
 
-    result["result"] = "ACK";
+    result["result"] = Json::objectValue;
 
     return (TREX_RPC_CMD_OK);
 }
@@ -612,14 +535,7 @@ TrexRpcCmdPauseTraffic::_run(const Json::Value &params, Json::Value &result) {
 trex_rpc_cmd_rc_e
 TrexRpcCmdResumeTraffic::_run(const Json::Value &params, Json::Value &result) {
 
-    uint8_t port_id = parse_byte(params, "port_id", result);
-
-    if (port_id >= get_stateless_obj()->get_port_count()) {
-        std::stringstream ss;
-        ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
-        generate_execute_err(result, ss.str());
-    }
-
+    uint8_t port_id = parse_port(params, result);
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
      try {
@@ -628,7 +544,7 @@ TrexRpcCmdResumeTraffic::_run(const Json::Value &params, Json::Value &result) {
         generate_execute_err(result, ex.what());
     }
 
-    result["result"] = "ACK";
+    result["result"] = Json::objectValue;
 
     return (TREX_RPC_CMD_OK);
 }
@@ -640,46 +556,80 @@ TrexRpcCmdResumeTraffic::_run(const Json::Value &params, Json::Value &result) {
 trex_rpc_cmd_rc_e
 TrexRpcCmdUpdateTraffic::_run(const Json::Value &params, Json::Value &result) {
 
-    uint8_t port_id = parse_byte(params, "port_id", result);
-
-    if (port_id >= get_stateless_obj()->get_port_count()) {
-        std::stringstream ss;
-        ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
-        generate_execute_err(result, ss.str());
-    }
-
+    uint8_t port_id = parse_port(params, result);
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
     /* multiplier */
-    const Json::Value &mul = parse_object(params, "mul", result);
 
-    std::string mul_type = parse_string(mul, "type", result);
-    double max_rate = parse_double(mul, "max", result);
+    const Json::Value &mul_obj  = parse_object(params, "mul", result);
 
-    double m = 0;
+    std::string type   = parse_choice(mul_obj, "type", TrexPortMultiplier::g_types, result);
+    std::string op     = parse_choice(mul_obj, "op", TrexPortMultiplier::g_ops, result);
+    double      value  = parse_double(mul_obj, "value", result);
 
-    /* dispatch according to type of multiplier  */
-    if (mul_type == "raw") {
-        m = max_rate;
+    TrexPortMultiplier mul(type, op, value);
 
-    } else if (mul_type == "max_bps") {
-        m = port->calculate_m_from_bps(max_rate);
-
-    } else if (mul_type == "max_pps") {
-        m = port->calculate_m_from_pps(max_rate);
-
-    } else {
-        generate_parse_err(result, "multiplier type can be either 'raw', 'max_bps' or 'max_pps'");
-    }
 
     try {
-        port->update_traffic(m);
+        port->update_traffic(mul);
     } catch (const TrexRpcException &ex) {
         generate_execute_err(result, ex.what());
     }
 
-    result["result"] = "ACK";
+    result["result"]["multiplier"] = port->get_multiplier();
 
     return (TREX_RPC_CMD_OK);
 }
 
+/***************************
+ * validate
+ *  
+ * checks that the port
+ * attached streams are 
+ * valid as a program 
+ **************************/
+trex_rpc_cmd_rc_e
+TrexRpcCmdValidate::_run(const Json::Value &params, Json::Value &result) {
+    uint8_t port_id = parse_port(params, result);
+    TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
+
+    const TrexStreamsGraphObj *graph = NULL;
+
+    try {
+        graph = port->validate();
+    }
+    catch (const TrexException &ex) {
+        generate_execute_err(result, ex.what());
+    }
+    
+
+    result["result"]["rate"]["max_bps"] = graph->get_max_bps();
+    result["result"]["rate"]["max_pps"] = graph->get_max_pps();
+    result["result"]["rate"]["max_line_util"] = graph->get_max_bps() / port->get_port_speed_bps();
+
+    result["result"]["graph"]["expected_duration"] = graph->get_duration();
+    result["result"]["graph"]["events_count"] = (int)graph->get_events().size();
+
+    result["result"]["graph"]["events"] = Json::arrayValue;
+    Json::Value &events_json = result["result"]["graph"]["events"];
+
+    int index = 0;
+    for (const auto &ev : graph->get_events()) {
+        Json::Value ev_json;
+
+        ev_json["time_usec"]  = ev.time;
+        ev_json["diff_bps"]   = ev.diff_bps;
+        ev_json["diff_pps"]   = ev.diff_pps;
+        ev_json["stream_id"]  = ev.stream_id;
+
+        events_json.append(ev_json);
+
+        index++;
+        if (index >= 100) {
+            break;
+        }
+    }
+
+
+    return (TREX_RPC_CMD_OK);
+}
diff --git a/src/rpc-server/commands/trex_rpc_cmd_test.cpp b/src/rpc-server/commands/trex_rpc_cmd_test.cpp
index 3cdddd31..ad4d3bb1 100644
--- a/src/rpc-server/commands/trex_rpc_cmd_test.cpp
+++ b/src/rpc-server/commands/trex_rpc_cmd_test.cpp
@@ -21,6 +21,7 @@ limitations under the License.
 #include "trex_rpc_cmds.h"
 #include <iostream>
 #include <sstream>
+#include <json/json.h>
 
 using namespace std;
 
@@ -31,7 +32,7 @@ using namespace std;
 trex_rpc_cmd_rc_e 
 TrexRpcCmdTestAdd::_run(const Json::Value &params, Json::Value &result) {
 
-    result["result"] = parse_int(params, "x", result) + parse_int(params, "y", result);
+    result["result"] = Json::Value::UInt64(parse_uint64(params, "x", result) + parse_uint64(params, "y", result));
     
     return (TREX_RPC_CMD_OK);
 }
@@ -44,7 +45,7 @@ TrexRpcCmdTestAdd::_run(const Json::Value &params, Json::Value &result) {
 trex_rpc_cmd_rc_e 
 TrexRpcCmdTestSub::_run(const Json::Value &params, Json::Value &result) {
 
-    result["result"] = parse_int(params, "x", result) - parse_int(params, "y", result);
+    result["result"] = Json::Value::UInt64(parse_uint64(params, "x", result) - parse_uint64(params, "y", result));
 
     return (TREX_RPC_CMD_OK);
 }
diff --git a/src/rpc-server/commands/trex_rpc_cmds.h b/src/rpc-server/commands/trex_rpc_cmds.h
index b4f37e3b..f4651d7b 100644
--- a/src/rpc-server/commands/trex_rpc_cmds.h
+++ b/src/rpc-server/commands/trex_rpc_cmds.h
@@ -70,14 +70,15 @@ void get_hostname(std::string &hostname);
  * ownership
  */
 TREX_RPC_CMD_DEFINE(TrexRpcCmdGetOwner,   "get_owner",       1, false);
-TREX_RPC_CMD_DEFINE(TrexRpcCmdAcquire,    "acquire",         3, false);
+TREX_RPC_CMD_DEFINE(TrexRpcCmdAcquire,    "acquire",         4, false);
 TREX_RPC_CMD_DEFINE(TrexRpcCmdRelease,    "release",         1, true);
 
 
 /**
  * port commands
  */
-TREX_RPC_CMD_DEFINE(TrexRpcCmdGetPortStats, "get_port_stats", 1, true);
+TREX_RPC_CMD_DEFINE(TrexRpcCmdGetPortStats, "get_port_stats", 1, false);
+TREX_RPC_CMD_DEFINE(TrexRpcCmdGetPortStatus, "get_port_status", 1, false);
 
 
 /**
@@ -94,14 +95,15 @@ void validate_stream(const TrexStream *stream, Json::Value &result);
 void parse_vm(const Json::Value &vm, TrexStream *stream, Json::Value &result);
 void parse_vm_instr_checksum(const Json::Value &inst, TrexStream *stream, Json::Value &result);
 void parse_vm_instr_flow_var(const Json::Value &inst, TrexStream *stream, Json::Value &result);
+void parse_vm_instr_tuple_flow_var(const Json::Value &inst, TrexStream *stream, Json::Value &result);
 void parse_vm_instr_write_flow_var(const Json::Value &inst, TrexStream *stream, Json::Value &result);
 );
 
 
-TREX_RPC_CMD_DEFINE(TrexRpcCmdGetStreamList, "get_stream_list", 1, true);
-TREX_RPC_CMD_DEFINE(TrexRpcCmdGetAllStreams, "get_all_streams", 2, true);
+TREX_RPC_CMD_DEFINE(TrexRpcCmdGetStreamList, "get_stream_list", 1, false);
+TREX_RPC_CMD_DEFINE(TrexRpcCmdGetAllStreams, "get_all_streams", 2, false);
 
-TREX_RPC_CMD_DEFINE(TrexRpcCmdGetStream, "get_stream", 3, true);
+TREX_RPC_CMD_DEFINE(TrexRpcCmdGetStream, "get_stream", 3, false);
 
 
 
@@ -112,7 +114,6 @@ TREX_RPC_CMD_DEFINE(TrexRpcCmdResumeTraffic, "resume_traffic", 1, true);
 
 TREX_RPC_CMD_DEFINE(TrexRpcCmdUpdateTraffic, "update_traffic", 2, true);
 
-TREX_RPC_CMD_DEFINE(TrexRpcCmdSyncUser, "sync_user", 2, false);
-
+TREX_RPC_CMD_DEFINE(TrexRpcCmdValidate, "validate", 2, false);
 
 #endif /* __TREX_RPC_CMD_H__ */
diff --git a/src/rpc-server/trex_rpc_cmd.cpp b/src/rpc-server/trex_rpc_cmd.cpp
index af0db3f4..b5dd121c 100644
--- a/src/rpc-server/trex_rpc_cmd.cpp
+++ b/src/rpc-server/trex_rpc_cmd.cpp
@@ -63,8 +63,12 @@ TrexRpcCommand::verify_ownership(const Json::Value &params, Json::Value &result)
 
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
-    if (!port->verify_owner_handler(handler)) {
-        generate_execute_err(result, "invalid handler provided. please pass the handler given when calling 'acquire' or take ownership");
+    if (port->get_owner().is_free()) {
+        generate_execute_err(result, "please acquire the port before modifying port state");
+    }
+
+    if (!port->get_owner().verify(handler)) {
+        generate_execute_err(result, "port is not owned by you or your current executing session");
     }
 }
 
@@ -92,6 +96,10 @@ TrexRpcCommand::type_to_str(field_type_e type) {
         return "byte";
     case FIELD_TYPE_UINT16:
         return "uint16";
+    case FIELD_TYPE_UINT32:
+        return "uint32";
+    case FIELD_TYPE_UINT64:
+        return "uint64";
     case FIELD_TYPE_BOOL:
         return "bool";
     case FIELD_TYPE_INT:
@@ -161,6 +169,30 @@ TrexRpcCommand::parse_uint16(const Json::Value &parent, int index, Json::Value &
     return parent[index].asUInt();
 }
 
+uint32_t 
+TrexRpcCommand::parse_uint32(const Json::Value &parent, const std::string &name, Json::Value &result) {
+    check_field_type(parent, name, FIELD_TYPE_UINT32, result);
+    return parent[name].asUInt();
+}
+
+uint32_t  
+TrexRpcCommand::parse_uint32(const Json::Value &parent, int index, Json::Value &result) {
+    check_field_type(parent, index, FIELD_TYPE_UINT32, result);
+    return parent[index].asUInt();
+}
+
+uint64_t 
+TrexRpcCommand::parse_uint64(const Json::Value &parent, const std::string &name, Json::Value &result) {
+    check_field_type(parent, name, FIELD_TYPE_UINT64, result);
+    return parent[name].asUInt64();
+}
+
+uint64_t  
+TrexRpcCommand::parse_uint64(const Json::Value &parent, int index, Json::Value &result) {
+    check_field_type(parent, index, FIELD_TYPE_UINT64, result);
+    return parent[index].asUInt64();
+}
+
 int
 TrexRpcCommand::parse_int(const Json::Value &parent, const std::string &name, Json::Value &result) {
     check_field_type(parent, name, FIELD_TYPE_INT, result);
@@ -185,12 +217,24 @@ TrexRpcCommand::parse_string(const Json::Value &parent, const std::string &name,
     return parent[name].asString();
 }
 
+/**
+ * object version
+ */
 const Json::Value &
 TrexRpcCommand::parse_object(const Json::Value &parent, const std::string &name, Json::Value &result) {
     check_field_type(parent, name, FIELD_TYPE_OBJ, result);
     return parent[name];
 }
 
+/**
+ * index version
+ */
+const Json::Value &
+TrexRpcCommand::parse_object(const Json::Value &parent, int index, Json::Value &result) {
+    check_field_type(parent, index, FIELD_TYPE_OBJ, result);
+    return parent[index];
+}
+
 const Json::Value &
 TrexRpcCommand::parse_array(const Json::Value &parent, const std::string &name, Json::Value &result) {
     check_field_type(parent, name, FIELD_TYPE_ARRAY, result);
@@ -250,6 +294,18 @@ TrexRpcCommand::check_field_type_common(const Json::Value &field, const std::str
         }
         break;
 
+    case FIELD_TYPE_UINT32:
+        if ( (!field.isUInt()) || (field.asUInt() > 0xFFFFFFFF)) {
+            rc = false;
+        }
+        break;
+
+    case FIELD_TYPE_UINT64:
+        if (!field.isInt64()) {
+            rc = false;
+        }
+        break;
+
     case FIELD_TYPE_BOOL:
         if (!field.isBool()) {
             rc = false;
diff --git a/src/rpc-server/trex_rpc_cmd_api.h b/src/rpc-server/trex_rpc_cmd_api.h
index 3c718eaa..7cbdf4ff 100644
--- a/src/rpc-server/trex_rpc_cmd_api.h
+++ b/src/rpc-server/trex_rpc_cmd_api.h
@@ -99,6 +99,8 @@ protected:
     enum field_type_e {
         FIELD_TYPE_BYTE,
         FIELD_TYPE_UINT16,
+        FIELD_TYPE_UINT32,
+        FIELD_TYPE_UINT64,
         FIELD_TYPE_INT,
         FIELD_TYPE_DOUBLE,
         FIELD_TYPE_BOOL,
@@ -136,6 +138,8 @@ protected:
      */
     uint8_t  parse_byte(const Json::Value &parent, const std::string &name, Json::Value &result);
     uint16_t parse_uint16(const Json::Value &parent, const std::string &name, Json::Value &result);
+    uint32_t parse_uint32(const Json::Value &parent, const std::string &name, Json::Value &result);
+    uint64_t parse_uint64(const Json::Value &parent, const std::string &name, Json::Value &result);
     int      parse_int(const Json::Value &parent, const std::string &name, Json::Value &result);
     double   parse_double(const Json::Value &parent, const std::string &name, Json::Value &result);
     bool     parse_bool(const Json::Value &parent, const std::string &name, Json::Value &result);
@@ -145,6 +149,8 @@ protected:
 
     uint8_t  parse_byte(const Json::Value &parent, int index, Json::Value &result);
     uint16_t parse_uint16(const Json::Value &parent, int index, Json::Value &result);
+    uint32_t parse_uint32(const Json::Value &parent, int index, Json::Value &result);
+    uint64_t parse_uint64(const Json::Value &parent, int index, Json::Value &result);
     int      parse_int(const Json::Value &parent, int index, Json::Value &result);
     double   parse_double(const Json::Value &parent, int index, Json::Value &result);
     bool     parse_bool(const Json::Value &parent, int index, Json::Value &result);
@@ -159,7 +165,7 @@ protected:
      * parse a field from choices 
      * 
      */
-    template<typename T> T parse_choice(const Json::Value &params, const std::string &name, std::initializer_list<T> choices, Json::Value &result) {
+    template<typename T> T parse_choice(const Json::Value &params, const std::string &name, const std::initializer_list<T> choices, Json::Value &result) {
         const Json::Value &field = params[name];
 
         if (field == Json::Value::null) {
diff --git a/src/rpc-server/trex_rpc_cmds_table.cpp b/src/rpc-server/trex_rpc_cmds_table.cpp
index a65bbccf..82c723b7 100644
--- a/src/rpc-server/trex_rpc_cmds_table.cpp
+++ b/src/rpc-server/trex_rpc_cmds_table.cpp
@@ -41,8 +41,8 @@ TrexRpcCommandsTable::TrexRpcCommandsTable() {
     register_command(new TrexRpcCmdAcquire());
     register_command(new TrexRpcCmdRelease());
     register_command(new TrexRpcCmdGetPortStats());
-
-    register_command(new TrexRpcCmdSyncUser());
+    register_command(new TrexRpcCmdGetPortStatus());
+    
 
     /* stream commands */
     register_command(new TrexRpcCmdAddStream());
@@ -57,8 +57,11 @@ TrexRpcCommandsTable::TrexRpcCommandsTable() {
     register_command(new TrexRpcCmdPauseTraffic());
     register_command(new TrexRpcCmdResumeTraffic());
     register_command(new TrexRpcCmdUpdateTraffic());
+
+    register_command(new TrexRpcCmdValidate());
 }
 
+
 TrexRpcCommandsTable::~TrexRpcCommandsTable() {
     for (auto cmd : m_rpc_cmd_table) {
         delete cmd.second;
diff --git a/src/rpc-server/trex_rpc_req_resp_server.cpp b/src/rpc-server/trex_rpc_req_resp_server.cpp
index 9147f75d..eb7825ac 100644
--- a/src/rpc-server/trex_rpc_req_resp_server.cpp
+++ b/src/rpc-server/trex_rpc_req_resp_server.cpp
@@ -26,6 +26,7 @@ limitations under the License.
 #include <unistd.h>
 #include <sstream>
 #include <iostream>
+#include <assert.h>
 
 #include <zmq.h>
 #include <json/json.h>
@@ -70,28 +71,14 @@ void TrexRpcServerReqRes::_rpc_thread_cb() {
 
     /* server main loop */
     while (m_is_running) {
-        int msg_size = zmq_recv (m_socket, m_msg_buffer, sizeof(m_msg_buffer), 0);
-
-        /* msg_size of -1 is an error - decode it */
-        if (msg_size == -1) {
-            /* normal shutdown and zmq_term was called */
-            if (errno == ETERM) {
-                break;
-            } else {
-                throw TrexRpcException("Unhandled error of zmq_recv");
-            }
-        }
+        std::string request;
 
-        if (msg_size >= sizeof(m_msg_buffer)) {
-            std::stringstream ss;
-            ss << "RPC request of '" << msg_size << "' exceeds maximum message size which is '" << sizeof(m_msg_buffer) << "'";
-            handle_server_error(ss.str());
-            continue;
+        /* get the next request */
+        bool rc = fetch_one_request(request);
+        if (!rc) {
+            break;
         }
 
-        /* transform it to a string */
-        std::string request((const char *)m_msg_buffer, msg_size);
-
         verbose_json("Server Received: ", TrexJsonRpcV2Parser::pretty_json_str(request));
 
         handle_request(request);
@@ -101,6 +88,35 @@ void TrexRpcServerReqRes::_rpc_thread_cb() {
     zmq_close(m_socket);
 }
 
+bool
+TrexRpcServerReqRes::fetch_one_request(std::string &msg) {
+
+    zmq_msg_t zmq_msg;
+    int rc;
+
+    rc = zmq_msg_init(&zmq_msg);
+    assert(rc == 0);
+
+    rc = zmq_msg_recv (&zmq_msg, m_socket, 0);
+
+    if (rc == -1) {
+        zmq_msg_close(&zmq_msg);
+        /* normal shutdown and zmq_term was called */
+        if (errno == ETERM) {
+            return false;
+        } else {
+            throw TrexRpcException("Unhandled error of zmq_recv");
+        }
+    }
+
+    const char *data =  (const char *)zmq_msg_data(&zmq_msg);
+    size_t len = zmq_msg_size(&zmq_msg);
+    msg.append(data, len);
+
+    zmq_msg_close(&zmq_msg);
+    return true;
+}
+
 /**
  * stops the ZMQ based RPC server
  * 
diff --git a/src/rpc-server/trex_rpc_req_resp_server.h b/src/rpc-server/trex_rpc_req_resp_server.h
index bc38c0ef..2876206c 100644
--- a/src/rpc-server/trex_rpc_req_resp_server.h
+++ b/src/rpc-server/trex_rpc_req_resp_server.h
@@ -39,14 +39,12 @@ protected:
     void _stop_rpc_thread();
 
 private:
-
+    bool fetch_one_request(std::string &msg);
     void handle_request(const std::string &request);
     void handle_server_error(const std::string &specific_err);
 
-    static const int    RPC_MAX_MSG_SIZE = (200 * 1024);
     void               *m_context;
     void               *m_socket;
-    uint8_t             m_msg_buffer[RPC_MAX_MSG_SIZE];
 };
 
 
diff --git a/src/stateless/cp/trex_stateless_port.cpp b/src/stateless/cp/trex_stateless_port.cpp
index 8e18a5bf..3a64f8c5 100644
--- a/src/stateless/cp/trex_stateless_port.cpp
+++ b/src/stateless/cp/trex_stateless_port.cpp
@@ -57,7 +57,6 @@ TrexStatelessPort::TrexStatelessPort(uint8_t port_id, const TrexPlatformApi *api
 
     m_port_id = port_id;
     m_port_state = PORT_STATE_IDLE;
-    clear_owner();
 
     /* get the platform specific data */
     api->get_interface_info(port_id, m_driver_name, m_speed);
@@ -85,18 +84,40 @@ TrexStatelessPort::TrexStatelessPort(uint8_t port_id, const TrexPlatformApi *api
  * @param force 
  */
 void 
-TrexStatelessPort::acquire(const std::string &user, bool force) {
-    if ( (!is_free_to_aquire()) && (get_owner() != user) && (!force)) {
-        throw TrexRpcException("port is already taken by '" + get_owner() + "'");
+TrexStatelessPort::acquire(const std::string &user, uint32_t session_id, bool force) {
+
+    /* if port is free - just take it */
+    if (get_owner().is_free()) {
+        get_owner().own(user);
+        return;
+    }
+
+    if (force) {
+        get_owner().own(user);
+
+        /* inform the other client of the steal... */
+        Json::Value data;
+
+        data["port_id"] = m_port_id;
+        data["who"] = user;
+        data["session_id"] = session_id;
+
+        get_stateless_obj()->get_publisher()->publish_event(TrexPublisher::EVENT_PORT_FORCE_ACQUIRED, data);
+
+    } else {
+        /* not same user or session id and not force - report error */
+        if (get_owner().get_name() == user) {
+            throw TrexRpcException("port is already owned by another session of '" + user + "'");
+        } else {
+            throw TrexRpcException("port is already taken by '" + get_owner().get_name() + "'");
+        }
     }
 
-    set_owner(user);
 }
 
 void
 TrexStatelessPort::release(void) {
-    verify_state( ~(PORT_STATE_TX | PORT_STATE_PAUSE) );
-    clear_owner();
+    get_owner().release();
 }
 
 /**
@@ -104,71 +125,71 @@ TrexStatelessPort::release(void) {
  * 
  */
 void
-TrexStatelessPort::start_traffic(double mul, double duration) {
+TrexStatelessPort::start_traffic(const TrexPortMultiplier &mul, double duration) {
 
     /* command allowed only on state stream */
     verify_state(PORT_STATE_STREAMS);
 
+    /* just making sure no leftovers... */
+    delete_streams_graph();
+
+    /* on start - we can only provide absolute values */
+    assert(mul.m_op == TrexPortMultiplier::OP_ABS);
+
+    double factor = calculate_effective_factor(mul);
+
     /* fetch all the streams from the table */
     vector<TrexStream *> streams;
     get_object_list(streams);
 
-    /* split it per core */
-    double per_core_mul = mul / m_cores_id_list.size();
 
     /* compiler it */
-    TrexStreamsCompiler compiler;
-    TrexStreamsCompiledObj *compiled_obj = new TrexStreamsCompiledObj(m_port_id, per_core_mul);
+    std::vector<TrexStreamsCompiledObj *> compiled_objs;
+    std::string fail_msg;
 
-    bool rc = compiler.compile(streams, *compiled_obj);
+    TrexStreamsCompiler compiler;
+    bool rc = compiler.compile(m_port_id,
+                               streams,
+                               compiled_objs,
+                               get_dp_core_count(),
+                               factor,
+                               &fail_msg);
     if (!rc) {
-        throw TrexRpcException("Failed to compile streams");
+        throw TrexRpcException(fail_msg);
     }
 
     /* generate a message to all the relevant DP cores to start transmitting */
     int event_id = m_dp_events.generate_event_id();
+
     /* mark that DP event of stoppped is possible */
     m_dp_events.wait_for_event(TrexDpPortEvent::EVENT_STOP, event_id);
 
-    TrexStatelessCpToDpMsgBase *start_msg = new TrexStatelessDpStart(m_port_id, event_id, compiled_obj, duration);
-
-    m_last_all_streams_continues = compiled_obj->get_all_streams_continues();
-    m_last_duration =duration;
 
+    /* update object status */
+    m_factor = factor;
+    m_last_all_streams_continues = compiled_objs[0]->get_all_streams_continues();
+    m_last_duration = duration;
     change_state(PORT_STATE_TX);
 
-    send_message_to_dp(start_msg);
+
+    /* update the DP - messages will be freed by the DP */
+    int index = 0;
+    for (auto core_id : m_cores_id_list) {
+
+        TrexStatelessCpToDpMsgBase *start_msg = new TrexStatelessDpStart(m_port_id, event_id, compiled_objs[index], duration);
+        send_message_to_dp(core_id, start_msg);
+
+        index++;
+    }
     
+    /* update subscribers */    
     Json::Value data;
     data["port_id"] = m_port_id;
     get_stateless_obj()->get_publisher()->publish_event(TrexPublisher::EVENT_PORT_STARTED, data);
+    
 }
 
 
-double
-TrexStatelessPort::calculate_m_from_bps(double max_bps) {
-    /* fetch all the streams from the table */
-    vector<TrexStream *> streams;
-    get_object_list(streams);
-
-    TrexStreamsGraph graph;
-    const TrexStreamsGraphObj &obj = graph.generate(streams);
-
-    return (max_bps / obj.get_max_bps());
-}
-
-double
-TrexStatelessPort::calculate_m_from_pps(double max_pps) {
-    /* fetch all the streams from the table */
-    vector<TrexStream *> streams;
-    get_object_list(streams);
-
-    TrexStreamsGraph graph;
-    const TrexStreamsGraphObj &obj = graph.generate(streams);
-
-    return (max_pps / obj.get_max_pps());
-}
-
 /**
  * stop traffic on port
  * 
@@ -180,17 +201,20 @@ void
 TrexStatelessPort::stop_traffic(void) {
 
     if (!( (m_port_state == PORT_STATE_TX) 
-        || (m_port_state ==PORT_STATE_PAUSE) )) {
+        || (m_port_state == PORT_STATE_PAUSE) )) {
         return;
     }
 
+    /* delete any previous graphs */
+    delete_streams_graph();
+
     /* mask out the DP stop event */
     m_dp_events.disable(TrexDpPortEvent::EVENT_STOP);
 
     /* generate a message to all the relevant DP cores to start transmitting */
     TrexStatelessCpToDpMsgBase *stop_msg = new TrexStatelessDpStop(m_port_id);
 
-    send_message_to_dp(stop_msg);
+    send_message_to_all_dp(stop_msg);
 
     change_state(PORT_STATE_STREAMS);
     
@@ -213,11 +237,15 @@ TrexStatelessPort::pause_traffic(void) {
         throw TrexRpcException(" pause is supported when duration is not enable is start command ");
     }
 
-    TrexStatelessCpToDpMsgBase *stop_msg = new TrexStatelessDpPause(m_port_id);
+    TrexStatelessCpToDpMsgBase *pause_msg = new TrexStatelessDpPause(m_port_id);
 
-    send_message_to_dp(stop_msg);
+    send_message_to_all_dp(pause_msg);
 
     change_state(PORT_STATE_PAUSE);
+
+    Json::Value data;
+    data["port_id"] = m_port_id;
+    get_stateless_obj()->get_publisher()->publish_event(TrexPublisher::EVENT_PORT_PAUSED, data);
 }
 
 void
@@ -226,23 +254,54 @@ TrexStatelessPort::resume_traffic(void) {
     verify_state(PORT_STATE_PAUSE);
 
     /* generate a message to all the relevant DP cores to start transmitting */
-    TrexStatelessCpToDpMsgBase *stop_msg = new TrexStatelessDpResume(m_port_id);
+    TrexStatelessCpToDpMsgBase *resume_msg = new TrexStatelessDpResume(m_port_id);
 
-    send_message_to_dp(stop_msg);
+    send_message_to_all_dp(resume_msg);
 
     change_state(PORT_STATE_TX);
+
+
+    Json::Value data;
+    data["port_id"] = m_port_id;
+    get_stateless_obj()->get_publisher()->publish_event(TrexPublisher::EVENT_PORT_RESUMED, data);
 }
 
 void
-TrexStatelessPort::update_traffic(double mul) {
+TrexStatelessPort::update_traffic(const TrexPortMultiplier &mul) {
+
+    double factor;
 
     verify_state(PORT_STATE_TX | PORT_STATE_PAUSE);
 
     /* generate a message to all the relevant DP cores to start transmitting */
-    double per_core_mul = mul / m_cores_id_list.size();
-    TrexStatelessCpToDpMsgBase *update_msg = new TrexStatelessDpUpdate(m_port_id, per_core_mul);
+    double new_factor = calculate_effective_factor(mul);
+
+    switch (mul.m_op) {
+    case TrexPortMultiplier::OP_ABS:
+        factor = new_factor / m_factor;
+        break;
+
+    case TrexPortMultiplier::OP_ADD:
+        factor = (m_factor + new_factor) / m_factor;
+        break;
+
+    case TrexPortMultiplier::OP_SUB:
+        factor = (m_factor - new_factor) / m_factor;
+        if (factor <= 0) {
+            throw TrexRpcException("Update request will lower traffic to less than zero");
+        }
+        break;
+
+    default:
+        assert(0);
+        break;
+    }
+
+    TrexStatelessCpToDpMsgBase *update_msg = new TrexStatelessDpUpdate(m_port_id, factor);
 
-    send_message_to_dp(update_msg);
+    send_message_to_all_dp(update_msg);
+
+    m_factor *= factor;
 
 }
 
@@ -295,27 +354,6 @@ TrexStatelessPort::change_state(port_state_e new_state) {
     m_port_state = new_state;
 }
 
-/**
- * generate a random connection handler
- * 
- */
-std::string 
-TrexStatelessPort::generate_handler() {
-    std::stringstream ss;
-
-    static const char alphanum[] =
-        "0123456789"
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-        "abcdefghijklmnopqrstuvwxyz";
-
-    /* generate 8 bytes of random handler */
-    for (int i = 0; i < 8; ++i) {
-        ss << alphanum[rand() % (sizeof(alphanum) - 1)];
-    }
-
-    return (ss.str());
-}
-
 
 void
 TrexStatelessPort::encode_stats(Json::Value &port) {
@@ -341,15 +379,22 @@ TrexStatelessPort::encode_stats(Json::Value &port) {
 }
 
 void 
-TrexStatelessPort::send_message_to_dp(TrexStatelessCpToDpMsgBase *msg) {
+TrexStatelessPort::send_message_to_all_dp(TrexStatelessCpToDpMsgBase *msg) {
 
     for (auto core_id : m_cores_id_list) {
-
-        /* send the message to the core */
-        CNodeRing *ring = CMsgIns::Ins()->getCpDp()->getRingCpToDp(core_id);
-        ring->Enqueue((CGenNode *)msg->clone());
+        send_message_to_dp(core_id, msg->clone());
     }
 
+    /* original was not sent - delete it */
+    delete msg;
+}
+
+void 
+TrexStatelessPort::send_message_to_dp(uint8_t core_id, TrexStatelessCpToDpMsgBase *msg) {
+
+    /* send the message to the core */
+    CNodeRing *ring = CMsgIns::Ins()->getCpDp()->getRingCpToDp(core_id);
+    ring->Enqueue((CGenNode *)msg);
 }
 
 /**
@@ -376,3 +421,201 @@ TrexStatelessPort::on_dp_event_occured(TrexDpPortEvent::event_e event_type) {
 
     }
 }
+
+uint64_t
+TrexStatelessPort::get_port_speed_bps() const {
+    switch (m_speed) {
+    case TrexPlatformApi::SPEED_1G:
+        return (1LLU * 1000 * 1000 * 1000);
+
+    case TrexPlatformApi::SPEED_10G:
+        return (10LLU * 1000 * 1000 * 1000);
+
+    case TrexPlatformApi::SPEED_40G:
+        return (40LLU * 1000 * 1000 * 1000);
+
+    default:
+        return 0;
+    }
+}
+
+double
+TrexStatelessPort::calculate_effective_factor(const TrexPortMultiplier &mul) {
+
+    /* for a simple factor request */
+    if (mul.m_type == TrexPortMultiplier::MUL_FACTOR) {
+        return (mul.m_value);
+    }
+
+    /* we now need the graph - generate it if we don't have it (happens once) */
+    if (!m_graph_obj) {
+        generate_streams_graph();
+    }
+
+    switch (mul.m_type) {
+    case TrexPortMultiplier::MUL_BPS:
+        return (mul.m_value / m_graph_obj->get_max_bps());
+
+    case TrexPortMultiplier::MUL_PPS:
+         return (mul.m_value / m_graph_obj->get_max_pps());
+
+    case TrexPortMultiplier::MUL_PERCENTAGE:
+        /* if abs percentage is from the line speed - otherwise its from the current speed */
+
+        if (mul.m_op == TrexPortMultiplier::OP_ABS) {
+            double required = (mul.m_value / 100.0) * get_port_speed_bps();
+            return (required / m_graph_obj->get_max_bps());
+        } else {
+            return (m_factor * (mul.m_value / 100.0));
+        }
+
+    default:
+        assert(0);
+    }
+
+}
+
+
+void
+TrexStatelessPort::generate_streams_graph() {
+
+    /* dispose of the old one */
+    if (m_graph_obj) {
+        delete_streams_graph();
+    }
+
+    /* fetch all the streams from the table */
+    vector<TrexStream *> streams;
+    get_object_list(streams);
+
+    TrexStreamsGraph graph;
+    m_graph_obj = graph.generate(streams);
+}
+
+void
+TrexStatelessPort::delete_streams_graph() {
+    if (m_graph_obj) {
+        delete m_graph_obj;
+        m_graph_obj = NULL;
+    }
+}
+
+
+
+/***************************
+ * port multiplier
+ * 
+ **************************/
+const std::initializer_list<std::string> TrexPortMultiplier::g_types = {"raw", "bps", "pps", "percentage"};
+const std::initializer_list<std::string> TrexPortMultiplier::g_ops   = {"abs", "add", "sub"};
+
+TrexPortMultiplier::
+TrexPortMultiplier(const std::string &type_str, const std::string &op_str, double value) {
+    mul_type_e type;
+    mul_op_e   op;
+
+    if (type_str == "raw") {
+        type = MUL_FACTOR; 
+
+    } else if (type_str == "bps") {
+        type = MUL_BPS;
+
+    } else if (type_str == "pps") {
+        type = MUL_PPS;
+
+    } else if (type_str == "percentage") {
+        type = MUL_PERCENTAGE;
+    } else {
+        throw TrexException("bad type str: " + type_str);
+    }
+
+    if (op_str == "abs") {
+        op = OP_ABS;
+
+    } else if (op_str == "add") {
+        op = OP_ADD;
+
+    } else if (op_str == "sub") {
+        op = OP_SUB;
+
+    } else {
+        throw TrexException("bad op str: " + op_str);
+    }
+
+    m_type  = type;
+    m_op    = op;
+    m_value = value;
+
+}
+
+const TrexStreamsGraphObj *
+TrexStatelessPort::validate(void) {
+
+    /* first compile the graph */
+
+    vector<TrexStream *> streams;
+    get_object_list(streams);
+
+    if (streams.size() == 0) {
+        throw TrexException("no streams attached to port");
+    }
+
+    TrexStreamsCompiler compiler;
+    std::vector<TrexStreamsCompiledObj *> compiled_objs;
+
+    std::string fail_msg;
+    bool rc = compiler.compile(m_port_id,
+                               streams,
+                               compiled_objs,
+                               get_dp_core_count(),
+                               1.0,
+                               &fail_msg);
+    if (!rc) {
+        throw TrexException(fail_msg);
+    }
+
+    for (auto obj : compiled_objs) {
+        delete obj;
+    }
+
+    /* now create a stream graph */
+    if (!m_graph_obj) {
+        generate_streams_graph();
+    }
+
+    return m_graph_obj;
+}
+
+
+/************* Trex Port Owner **************/
+
+TrexPortOwner::TrexPortOwner() {
+    m_is_free = true;
+
+    /* for handlers random generation */
+    srand(time(NULL));
+}
+
+/**
+ * generate a random connection handler
+ * 
+ */
+std::string 
+TrexPortOwner::generate_handler() {
+    std::stringstream ss;
+
+    static const char alphanum[] =
+        "0123456789"
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        "abcdefghijklmnopqrstuvwxyz";
+
+    /* generate 8 bytes of random handler */
+    for (int i = 0; i < 8; ++i) {
+        ss << alphanum[rand() % (sizeof(alphanum) - 1)];
+    }
+
+    return (ss.str());
+}
+
+const std::string TrexPortOwner::g_unowned_name = "<FREE>";
+const std::string TrexPortOwner::g_unowned_handler = "";
diff --git a/src/stateless/cp/trex_stateless_port.h b/src/stateless/cp/trex_stateless_port.h
index b061a414..a529d38f 100644
--- a/src/stateless/cp/trex_stateless_port.h
+++ b/src/stateless/cp/trex_stateless_port.h
@@ -26,6 +26,79 @@ limitations under the License.
 #include <internal_api/trex_platform_api.h>
 
 class TrexStatelessCpToDpMsgBase;
+class TrexStreamsGraphObj;
+class TrexPortMultiplier;
+
+/** 
+ * TRex port owner can perform
+ * write commands
+ * while port is owned - others can
+ * do read only commands
+ * 
+ */
+class TrexPortOwner {
+public:
+
+    TrexPortOwner();
+
+    /**
+     * is port free to acquire
+     */
+    bool is_free() {
+        return m_is_free;
+    }
+
+    void release() {
+        m_is_free = true;
+        m_owner_name = "";
+        m_handler = "";
+    }
+
+    bool is_owned_by(const std::string &user) {
+        return ( !m_is_free && (m_owner_name == user) );
+    }
+
+    void own(const std::string &owner_name) {
+
+        /* save user data */
+        m_owner_name = owner_name;
+
+        /* internal data */
+        m_handler = generate_handler();
+        m_is_free = false;
+    }
+
+    bool verify(const std::string &handler) {
+        return ( (!m_is_free) && (m_handler == handler) );
+    }
+
+    const std::string &get_name() {
+        return (!m_is_free ? m_owner_name : g_unowned_name);
+    }
+
+    const std::string &get_handler() {
+        return (!m_is_free ? m_handler : g_unowned_handler);
+    }
+
+
+private:
+    std::string  generate_handler();
+
+    /* is this port owned by someone ? */
+    bool         m_is_free;
+
+    /* user provided info */
+    std::string  m_owner_name;
+
+    /* handler genereated internally */
+    std::string  m_handler;
+    
+
+    /* just references defaults... */
+    static const std::string g_unowned_name;
+    static const std::string g_unowned_handler;
+};
+
 
 /**
  * describes a stateless port
@@ -58,13 +131,14 @@ public:
         RC_ERR_FAILED_TO_COMPILE_STREAMS
     };
 
+  
     TrexStatelessPort(uint8_t port_id, const TrexPlatformApi *api);
     
     /**
      * acquire port
      * throws TrexException in case of an error
      */
-    void acquire(const std::string &user, bool force = false);
+    void acquire(const std::string &user, uint32_t session_id, bool force = false);
 
     /**
      * release the port from the current user
@@ -73,22 +147,20 @@ public:
     void release(void);
 
     /**
-     * start traffic
-     * throws TrexException in case of an error
+     * validate the state of the port before start 
+     * it will return a stream graph 
+     * containing information about the streams 
+     * configured on this port 
+     *  
+     * on error it throws TrexException
      */
-    void start_traffic(double mul, double duration = -1);
+    const TrexStreamsGraphObj *validate(void);
 
     /**
-     * given a BPS rate calculate ther correct M for this port
-     * 
-     */
-    double calculate_m_from_bps(double max_bps);
-
-    /**
-     * given a PPS rate calculate the correct M for this port
-     * 
+     * start traffic
+     * throws TrexException in case of an error
      */
-    double calculate_m_from_pps(double max_pps);
+    void start_traffic(const TrexPortMultiplier &mul, double duration);
 
     /**
      * stop traffic
@@ -112,7 +184,7 @@ public:
      * update current traffic on port
      * 
      */
-    void update_traffic(double mul);
+    void update_traffic(const TrexPortMultiplier &mul);
 
     /**
      * get the port state
@@ -139,29 +211,6 @@ public:
     void get_properties(std::string &driver, TrexPlatformApi::driver_speed_e &speed);
 
 
-    /**
-    * query for ownership
-    * 
-    */
-    const std::string &get_owner() {
-        return m_owner;
-    }
-
-    /**
-     * owner handler 
-     * for the connection 
-     * 
-     */
-    const std::string &get_owner_handler() {
-        return m_owner_handler;
-    }
-
-
-    bool verify_owner_handler(const std::string &handler) {
-
-        return ( (m_owner != "none") && (m_owner_handler == handler) );
-
-    }
 
     /**
      * encode stats as JSON
@@ -181,6 +230,7 @@ public:
         verify_state(PORT_STATE_IDLE | PORT_STATE_STREAMS);
 
         m_stream_table.add_stream(stream);
+        delete_streams_graph();
 
         change_state(PORT_STATE_STREAMS);
     }
@@ -189,6 +239,7 @@ public:
         verify_state(PORT_STATE_STREAMS);
 
         m_stream_table.remove_stream(stream);
+        delete_streams_graph();
 
         if (m_stream_table.size() == 0) {
             change_state(PORT_STATE_IDLE);
@@ -199,6 +250,7 @@ public:
         verify_state(PORT_STATE_IDLE | PORT_STATE_STREAMS);
 
         m_stream_table.remove_and_delete_all_streams();
+        delete_streams_graph();
 
         change_state(PORT_STATE_IDLE);
     }
@@ -220,31 +272,34 @@ public:
     }
 
 
-
-private:
-
-  
-
     /**
-    * take ownership of the server array 
-    * this is static 
-    * ownership is total 
-    * 
-    */
-    void set_owner(const std::string &owner) {
-        m_owner = owner;
-        m_owner_handler = generate_handler();
+     * returns the number of DP cores linked to this port
+     * 
+     */
+    uint8_t get_dp_core_count() {
+        return m_cores_id_list.size();
     }
 
-    void clear_owner() {
-        m_owner = "none";
-        m_owner_handler = "";
+    /**
+     * returns the traffic multiplier currently being used by the DP
+     * 
+     */
+    double get_multiplier() {
+        return (m_factor);
     }
 
-    bool is_free_to_aquire() {
-        return (m_owner == "none");
+    /**
+     * get port speed in bits per second
+     * 
+     */
+    uint64_t get_port_speed_bps() const;
+
+    TrexPortOwner & get_owner() {
+        return m_owner;
     }
 
+private:
+
 
     const std::vector<int> get_core_id_list () {
         return m_cores_id_list;
@@ -256,7 +311,17 @@ private:
 
     std::string generate_handler();
 
-    void send_message_to_dp(TrexStatelessCpToDpMsgBase *msg);
+    /**
+     * send message to all cores using duplicate
+     * 
+     */
+    void send_message_to_all_dp(TrexStatelessCpToDpMsgBase *msg);
+
+    /**
+     * send message to specific DP core
+     * 
+     */
+    void send_message_to_dp(uint8_t core_id, TrexStatelessCpToDpMsgBase *msg);
 
     /**
      * triggered when event occurs
@@ -265,22 +330,97 @@ private:
     void on_dp_event_occured(TrexDpPortEvent::event_e event_type);
 
 
+    /**
+     * calculate effective M per core
+     * 
+     */
+    double calculate_effective_factor(const TrexPortMultiplier &mul);
+
+  
+
+    /**
+     * generates a graph of streams graph
+     * 
+     */
+    void generate_streams_graph();
+
+    /**
+     * dispose of it
+     * 
+     * @author imarom (26-Nov-15)
+     */
+    void delete_streams_graph();
+
+
     TrexStreamTable    m_stream_table;
     uint8_t            m_port_id;
     port_state_e       m_port_state;
-    std::string        m_owner;
-    std::string        m_owner_handler;
     std::string        m_driver_name;
 
     TrexPlatformApi::driver_speed_e m_speed;
 
     /* holds the DP cores associated with this port */
-    std::vector<int> m_cores_id_list;
+    std::vector<int>   m_cores_id_list;
 
     bool               m_last_all_streams_continues;
     double             m_last_duration;
+    double             m_factor;
 
     TrexDpPortEvents   m_dp_events;
+
+    /* holds a graph of streams rate*/
+    const TrexStreamsGraphObj  *m_graph_obj;
+
+    /* owner information */
+    TrexPortOwner       m_owner;
+};
+
+
+/**
+ * port multiplier object
+ * 
+ */
+class TrexPortMultiplier {
+public:
+
+
+    /**
+     * defines the type of multipler passed to start
+     */
+    enum mul_type_e {
+        MUL_FACTOR,
+        MUL_BPS,
+        MUL_PPS,
+        MUL_PERCENTAGE
+    };
+
+    /**
+     * multiplier can be absolute value 
+     * increment value or subtract value 
+     */
+    enum mul_op_e {
+        OP_ABS,
+        OP_ADD,
+        OP_SUB
+    };
+
+
+    TrexPortMultiplier(mul_type_e type, mul_op_e op, double value) {
+        m_type   = type;
+        m_op     = op;
+        m_value  = value;
+    }
+
+    TrexPortMultiplier(const std::string &type_str, const std::string &op_str, double value);
+
+
+public:
+    static const std::initializer_list<std::string> g_types;
+    static const std::initializer_list<std::string> g_ops;
+
+    mul_type_e  m_type;
+    mul_op_e    m_op;
+    double      m_value;
 };
 
 #endif /* __TREX_STATELESS_PORT_H__ */
diff --git a/src/stateless/cp/trex_stream.cpp b/src/stateless/cp/trex_stream.cpp
index cad603e2..02f43a3a 100644
--- a/src/stateless/cp/trex_stream.cpp
+++ b/src/stateless/cp/trex_stream.cpp
@@ -53,6 +53,36 @@ std::string TrexStream::get_stream_type_str(stream_type_t stream_type){
 }
 
 
+void
+TrexStream::compile() {
+
+    /* in case there are no instructions - nothing to do */
+    if (m_vm.is_vm_empty()) {
+        m_has_vm = false;
+        return;
+    }
+
+    m_has_vm = true;
+
+    m_vm.set_packet_size(m_pkt.len);
+
+    m_vm.compile();
+
+    #if 0
+    m_vm.Dump(stdout);
+    #endif
+
+    m_vm_dp = m_vm.cloneAsVmDp();
+
+    /* calc m_vm_prefix_size which is the size of the writable packet */
+    uint16_t max_pkt_offset = m_vm_dp->get_max_packet_update_offset();
+    uint16_t pkt_size = m_pkt.len;
+
+    /* calculate the mbuf size that we should allocate */
+    m_vm_prefix_size = calc_writable_mbuf_size(max_pkt_offset, pkt_size);
+}
+
+
 void TrexStream::Dump(FILE *fd){
 
     fprintf(fd,"\n");
@@ -103,6 +133,8 @@ TrexStream::TrexStream(uint8_t type,
 
     m_pkt.binary = NULL;
     m_pkt.len    = 0;
+    m_has_vm = false;
+    m_vm_prefix_size = 0;
 
     m_rx_check.m_enable = false;
 
@@ -111,12 +143,17 @@ TrexStream::TrexStream(uint8_t type,
     m_burst_total_pkts=0; 
     m_num_bursts=1; 
     m_ibg_usec=0.0;  
+    m_vm_dp = NULL;
 }
 
 TrexStream::~TrexStream() {
     if (m_pkt.binary) {
         delete [] m_pkt.binary;
     }
+    if ( m_vm_dp ){
+        delete  m_vm_dp;
+        m_vm_dp=NULL;
+    }
 }
 
 void
@@ -199,3 +236,4 @@ int TrexStreamTable::size() {
     return m_stream_table.size();
 }
 
+
diff --git a/src/stateless/cp/trex_stream.h b/src/stateless/cp/trex_stream.h
index 3e48d7e4..720246f6 100644
--- a/src/stateless/cp/trex_stream.h
+++ b/src/stateless/cp/trex_stream.h
@@ -36,6 +36,54 @@ limitations under the License.
 class TrexRpcCmdAddStream;
 
 
+static inline uint16_t get_log2_size(uint16_t size){
+
+    uint16_t _sizes[]={64,128,256,512,1024,2048};
+    int i;
+    for (i=0; i<sizeof(_sizes)/sizeof(_sizes[0]); i++) {
+        if (size<=_sizes[i]) {
+            return (_sizes[i]);
+        }
+    }
+    assert(0);
+    return (0);
+}
+
+/**
+ *  calculate the size of writable mbuf in bytes. maximum size if packet size 
+ * 
+ * @param max_offset_writable
+ *                 the last byte that we don't write too. for example when 63 it means that bytes [62] in the array is written (zero base)
+ * @param pkt_size packet size in bytes
+ * 
+ * @return the writable size of the first mbuf . the idea is to give at least 64 bytes const mbuf else all packet will be writeable 
+ * 
+ * examples:
+ *       max_offset_writable =63
+ *       pkt_size =62
+ *        ==>62
+ * 
+ */
+static inline uint16_t calc_writable_mbuf_size(uint16_t max_offset_writable,
+                                 uint16_t pkt_size){
+
+    if ( pkt_size<=64 ){
+        return (pkt_size);
+    }
+    if (pkt_size<=128) {
+        return (pkt_size);
+    }
+
+    //pkt_size> 128
+    uint16_t non_writable = pkt_size - (max_offset_writable -1) ;
+    if ( non_writable<64 ) {
+        return (pkt_size);
+    }
+    return(max_offset_writable-1);
+}
+
+
+
 struct CStreamPktData {
         uint8_t      *binary;
         uint16_t      len;
@@ -129,9 +177,18 @@ public:
     }
 
     /* create new stream */
-    TrexStream * clone_as_dp(){
-            TrexStream * dp=new TrexStream(m_type,m_port_id,m_stream_id);
-        
+    TrexStream * clone_as_dp() const {
+
+            TrexStream *dp = new TrexStream(m_type,m_port_id,m_stream_id);
+            dp->m_has_vm = m_has_vm;
+            if (m_vm_dp) {
+                /* should have vm */
+                assert(m_has_vm);
+                dp->m_vm_dp = m_vm_dp->clone();
+            }else{
+                dp->m_vm_dp = NULL;
+            }
+            dp->m_vm_prefix_size = m_vm_prefix_size;
 
             dp->m_isg_usec      = m_isg_usec;
             dp->m_next_stream_id = m_next_stream_id;
@@ -161,10 +218,28 @@ public:
     }
 
     void Dump(FILE *fd);
+
+    bool is_vm(){
+        return (  m_has_vm );
+    }
+
+    StreamVmDp  * getDpVm(){
+        return ( m_vm_dp);
+    }
+
+    void post_vm_compile();
+
+    /**
+     * internal compilation of stream (for DP)
+     * 
+     */
+    void compile();
+
 public:
     /* basic */
     uint8_t       m_type;
     uint8_t       m_port_id;
+    uint16_t      m_vm_prefix_size;          /* writeable mbuf size */
     uint32_t      m_stream_id;              /* id from RPC can be anything */
     
 
@@ -175,6 +250,10 @@ public:
     /* indicators */
     bool          m_enabled;
     bool          m_self_start;
+    bool          m_has_vm; /* do we have instructions to run */
+
+
+    StreamVmDp  * m_vm_dp; /* compile VM  */
 
     CStreamPktData   m_pkt;
     /* pkt */
diff --git a/src/stateless/cp/trex_stream_vm.cpp b/src/stateless/cp/trex_stream_vm.cpp
index 2e760ae9..e10e1a81 100644
--- a/src/stateless/cp/trex_stream_vm.cpp
+++ b/src/stateless/cp/trex_stream_vm.cpp
@@ -1,5 +1,6 @@
 /*
  Itay Marom
+ Hanoch Haim 
  Cisco Systems, Inc.
 */
 
@@ -19,6 +20,108 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 #include <trex_stream_vm.h>
+#include <sstream>
+#include <assert.h>
+#include <iostream>
+#include <trex_stateless.h>
+#include <common/Network/Packet/IPHeader.h>
+#include <common/basic_utils.h>
+
+
+
+
+void StreamVmInstructionFixChecksumIpv4::Dump(FILE *fd){
+    fprintf(fd," fix_check_sum , %lu \n",(ulong)m_pkt_offset);
+}
+
+
+void StreamVmInstructionFlowMan::sanity_check_valid_size(uint32_t ins_id,StreamVm *lp){
+    uint8_t valid[]={1,2,4,8};
+    int i;
+    for (i=0; i<sizeof(valid)/sizeof(valid[0]); i++) {
+        if (valid[i]==m_size_bytes) {
+            return;
+        }
+    }
+
+    std::stringstream ss;
+
+    ss << "instruction id '" << ins_id << "' has non valid length " << m_size_bytes ;
+
+    lp->err(ss.str());
+}
+
+void StreamVmInstructionFlowMan::sanity_check_valid_opt(uint32_t ins_id,StreamVm *lp){
+    uint8_t valid[]={FLOW_VAR_OP_INC,
+        FLOW_VAR_OP_DEC,
+        FLOW_VAR_OP_RANDOM};
+    int i;
+    for (i=0; i<sizeof(valid)/sizeof(valid[0]); i++) {
+        if (valid[i]==m_op) {
+            return;
+        }
+    }
+
+    std::stringstream ss;
+
+    ss << "instruction id '" << ins_id << "' has non valid op " << (int)m_op ;
+
+    lp->err(ss.str());
+}
+
+void StreamVmInstructionFlowMan::sanity_check_valid_range(uint32_t ins_id,StreamVm *lp){
+    //TBD check that init,min,max in valid range 
+}
+
+
+
+void StreamVmInstructionFlowMan::sanity_check(uint32_t ins_id,StreamVm *lp){
+
+    sanity_check_valid_size(ins_id,lp);
+    sanity_check_valid_opt(ins_id,lp);
+    sanity_check_valid_range(ins_id,lp);
+}
+
+
+void StreamVmInstructionFlowMan::Dump(FILE *fd){
+    fprintf(fd," flow_var  , %s ,%lu,  ",m_var_name.c_str(),(ulong)m_size_bytes);
+
+    switch (m_op) {
+    
+    case FLOW_VAR_OP_INC :
+        fprintf(fd," INC    ,");
+        break;
+    case FLOW_VAR_OP_DEC :
+        fprintf(fd," DEC    ,");
+        break;
+    case FLOW_VAR_OP_RANDOM :
+        fprintf(fd," RANDOM ,");
+        break;
+    default:
+        fprintf(fd," UNKNOWN,");
+        break;
+    };
+
+    fprintf(fd," (%lu:%lu:%lu) \n",m_init_value,m_min_value,m_max_value);
+}
+
+
+void StreamVmInstructionWriteToPkt::Dump(FILE *fd){
+
+    fprintf(fd," write_pkt , %s ,%lu, add, %ld, big, %lu \n",m_flow_var_name.c_str(),(ulong)m_pkt_offset,(long)m_add_value,(ulong)(m_is_big_endian?1:0));
+}
+
+
+
+void StreamVmInstructionFlowClient::Dump(FILE *fd){
+
+    fprintf(fd," client_var ,%s , ",m_var_name.c_str());
+
+    fprintf(fd," ip:(%x-%x) port:(%x-%x)  flow_limit:%lu  flags: %x\n",m_client_min,m_client_max, m_port_min,m_port_max,(ulong)m_limit_num_flows,m_flags);
+}
+
+
+
 
 /***************************
  * StreamVmInstruction
@@ -36,19 +139,714 @@ void StreamVm::add_instruction(StreamVmInstruction *inst) {
     m_inst_list.push_back(inst);
 }
 
+StreamDPVmInstructions  *
+StreamVm::get_dp_instruction_buffer(){
+    return &m_instructions;
+}
+
+
 const std::vector<StreamVmInstruction *> & 
 StreamVm::get_instruction_list() {
     return m_inst_list;
 }
 
-bool StreamVm::compile() {
-    /* implement me */
-    return (false);
+void  StreamVm::var_clear_table(){
+    m_flow_var_offset.clear();
+}
+
+bool StreamVm::var_add(const std::string &var_name,VmFlowVarRec & var){
+    m_flow_var_offset[var_name] = var;
+    return (true);
+}
+
+
+uint16_t StreamVm::get_var_offset(const std::string &var_name){
+    VmFlowVarRec var;
+    bool res=var_lookup(var_name,var);
+    assert(res);
+    return (var.m_offset);
+}
+
+
+bool StreamVm::var_lookup(const std::string &var_name,VmFlowVarRec & var){
+    auto search = m_flow_var_offset.find(var_name);
+
+    if (search != m_flow_var_offset.end()) {
+        var =  search->second;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+
+
+void  StreamVm::err(const std::string &err){
+    throw TrexException("*** error: " + err);
+}
+
+
+void StreamVm::build_flow_var_table() {
+
+    var_clear_table();
+    m_cur_var_offset=0;
+    uint32_t ins_id=0;
+        /* scan all flow var instruction and build */
+    for (auto inst : m_inst_list) {
+        if ( inst->get_instruction_type() == StreamVmInstruction::itFLOW_MAN ){
+
+            StreamVmInstructionFlowMan * ins_man=(StreamVmInstructionFlowMan *)inst;
+
+            /* check that instruction is valid */
+            ins_man->sanity_check(ins_id,this);
+
+            VmFlowVarRec var;
+            /* if this is the first time */ 
+            if ( var_lookup( ins_man->m_var_name,var) == true){
+                std::stringstream ss;
+                ss << "instruction id '" << ins_id << "' flow variable name " << ins_man->m_var_name << " already exists";
+                err(ss.str());
+            }else{
+                var.m_offset=m_cur_var_offset;
+                var.m_ins.m_ins_flowv = ins_man;
+                var.m_size_bytes = ins_man->m_size_bytes;
+                var_add(ins_man->m_var_name,var);
+                m_cur_var_offset += ins_man->m_size_bytes;
+
+            }
+        }
+
+        if ( inst->get_instruction_type() == StreamVmInstruction::itFLOW_CLIENT ){
+            StreamVmInstructionFlowClient * ins_man=(StreamVmInstructionFlowClient *)inst;
+
+            VmFlowVarRec var;
+            /* if this is the first time */ 
+            if ( var_lookup( ins_man->m_var_name+".ip",var) == true){
+                std::stringstream ss;
+                ss << "instruction id '" << ins_id << "' client variable name " << ins_man->m_var_name << " already exists";
+                err(ss.str());
+            }
+            if ( var_lookup( ins_man->m_var_name+".port",var) == true){
+                std::stringstream ss;
+                ss << "instruction id '" << ins_id << "' client variable name " << ins_man->m_var_name << " already exists";
+                err(ss.str());
+            }
+
+            if ( var_lookup( ins_man->m_var_name+".flow_limit",var) == true){
+                std::stringstream ss;
+                ss << "instruction id '" << ins_id << "' client variable name " << ins_man->m_var_name << " already exists";
+                err(ss.str());
+            }
+
+            var.m_offset = m_cur_var_offset;
+            var.m_ins.m_ins_flow_client = ins_man;
+            var.m_size_bytes =4;
+
+            VmFlowVarRec var_port;
+
+            var_port.m_offset = m_cur_var_offset+4;
+            var_port.m_ins.m_ins_flow_client = ins_man;
+            var_port.m_size_bytes =2;
+
+            VmFlowVarRec var_flow_limit;
+
+            var_flow_limit.m_offset = m_cur_var_offset+6;
+            var_flow_limit.m_ins.m_ins_flow_client = ins_man;
+            var_flow_limit.m_size_bytes =4;
+
+
+            var_add(ins_man->m_var_name+".ip",var);
+            var_add(ins_man->m_var_name+".port",var_port);
+            var_add(ins_man->m_var_name+".flow_limit",var_flow_limit);
+
+            m_cur_var_offset += StreamVmInstructionFlowClient::get_flow_var_size(); 
+
+            assert(sizeof(StreamDPFlowClient)==StreamVmInstructionFlowClient::get_flow_var_size());
+        }
+
+        /* limit the flow var size */
+        if (m_cur_var_offset > StreamVm::svMAX_FLOW_VAR ) {
+            std::stringstream ss;
+            ss << "too many flow varibles current size is :" << m_cur_var_offset << " maximum support is " << StreamVm::svMAX_FLOW_VAR;
+            err(ss.str());
+        }
+        ins_id++;
+    }
+
+}
+
+void StreamVm::alloc_bss(){
+    free_bss();
+    m_bss=(uint8_t *)malloc(m_cur_var_offset);
+}
+
+void StreamVm::clean_max_field_cnt(){
+    m_max_field_update=0;
+}
+
+void StreamVm::add_field_cnt(uint16_t new_cnt){
+
+    if ( new_cnt > m_max_field_update) {
+        m_max_field_update = new_cnt;
+    }
+}
+
+
+void StreamVm::free_bss(){
+    if (m_bss) {
+        free(m_bss);
+        m_bss=0;
+    }
+}
+
+
+void StreamVm::build_program(){
+
+    /* build the commands into a buffer */
+    m_instructions.clear();
+    clean_max_field_cnt();
+    uint32_t ins_id=0;
+
+    for (auto inst : m_inst_list) {
+        StreamVmInstruction::instruction_type_t ins_type=inst->get_instruction_type();
+
+        /* itFIX_IPV4_CS */
+        if (ins_type == StreamVmInstruction::itFIX_IPV4_CS) {
+            StreamVmInstructionFixChecksumIpv4 *lpFix =(StreamVmInstructionFixChecksumIpv4 *)inst;
+
+            add_field_cnt(lpFix->m_pkt_offset +12);
+
+            if ( (lpFix->m_pkt_offset + IPV4_HDR_LEN) > m_pkt_size  ) {
+
+                std::stringstream ss;
+                ss << "instruction id '" << ins_id << "' fix ipv4 command offset  " << lpFix->m_pkt_offset << "  is too high relative to packet size  "<< m_pkt_size;
+                err(ss.str());
+            }
+
+            StreamDPOpIpv4Fix ipv_fix;
+            ipv_fix.m_offset = lpFix->m_pkt_offset;
+            ipv_fix.m_op = StreamDPVmInstructions::ditFIX_IPV4_CS;
+            m_instructions.add_command(&ipv_fix,sizeof(ipv_fix));
+        }
+
+
+        /* flow man */
+        if (ins_type == StreamVmInstruction::itFLOW_MAN) {
+            StreamVmInstructionFlowMan *lpMan =(StreamVmInstructionFlowMan *)inst;
+
+
+            if (lpMan->m_size_bytes == 1 ){
+
+                uint8_t op=StreamDPVmInstructions::ditINC8;
+
+                if ( lpMan->m_op == StreamVmInstructionFlowMan::FLOW_VAR_OP_INC ){
+                    op = StreamDPVmInstructions::ditINC8 ;
+                }
+
+                if ( lpMan->m_op == StreamVmInstructionFlowMan::FLOW_VAR_OP_DEC ){
+                    op = StreamDPVmInstructions::ditDEC8 ;
+                }
+
+                if ( lpMan->m_op == StreamVmInstructionFlowMan::FLOW_VAR_OP_RANDOM ){
+                    op = StreamDPVmInstructions::ditRANDOM8 ;
+                }
+
+                StreamDPOpFlowVar8 fv8;
+                fv8.m_op = op;
+                fv8.m_flow_offset = get_var_offset(lpMan->m_var_name);
+                fv8.m_min_val     = (uint8_t)lpMan->m_min_value;
+                fv8.m_max_val     = (uint8_t)lpMan->m_max_value;
+                m_instructions.add_command(&fv8,sizeof(fv8));
+            }
+
+            if (lpMan->m_size_bytes == 2 ){
+                uint8_t op;
+
+                op = StreamDPVmInstructions::ditINC16;
+
+                if ( lpMan->m_op == StreamVmInstructionFlowMan::FLOW_VAR_OP_INC ){
+                    op = StreamDPVmInstructions::ditINC16 ;
+                }
+
+                if ( lpMan->m_op == StreamVmInstructionFlowMan::FLOW_VAR_OP_DEC ){
+                    op = StreamDPVmInstructions::ditDEC16 ;
+                }
+
+                if ( lpMan->m_op == StreamVmInstructionFlowMan::FLOW_VAR_OP_RANDOM ){
+                    op = StreamDPVmInstructions::ditRANDOM16 ;
+                }
+
+                StreamDPOpFlowVar16 fv16;
+                fv16.m_op = op;
+                fv16.m_flow_offset = get_var_offset(lpMan->m_var_name);
+                fv16.m_min_val     = (uint16_t)lpMan->m_min_value;
+                fv16.m_max_val     = (uint16_t)lpMan->m_max_value;
+                m_instructions.add_command(&fv16,sizeof(fv16));
+            }
+
+            if (lpMan->m_size_bytes == 4 ){
+                uint8_t op;
+
+                op = StreamDPVmInstructions::ditINC32;
+
+                if ( lpMan->m_op == StreamVmInstructionFlowMan::FLOW_VAR_OP_INC ){
+                    op = StreamDPVmInstructions::ditINC32 ;
+                }
+
+                if ( lpMan->m_op == StreamVmInstructionFlowMan::FLOW_VAR_OP_DEC ){
+                    op = StreamDPVmInstructions::ditDEC32 ;
+                }
+
+                if ( lpMan->m_op == StreamVmInstructionFlowMan::FLOW_VAR_OP_RANDOM ){
+                    op = StreamDPVmInstructions::ditRANDOM32 ;
+                }
+
+                StreamDPOpFlowVar32 fv32;
+                fv32.m_op = op;
+                fv32.m_flow_offset = get_var_offset(lpMan->m_var_name);
+                fv32.m_min_val     = (uint32_t)lpMan->m_min_value;
+                fv32.m_max_val     = (uint32_t)lpMan->m_max_value;
+                m_instructions.add_command(&fv32,sizeof(fv32));
+            }
+
+            if (lpMan->m_size_bytes == 8 ){
+                uint8_t op;
+
+                op = StreamDPVmInstructions::ditINC64;
+
+                if ( lpMan->m_op == StreamVmInstructionFlowMan::FLOW_VAR_OP_INC ){
+                    op = StreamDPVmInstructions::ditINC64 ;
+                }
+
+                if ( lpMan->m_op == StreamVmInstructionFlowMan::FLOW_VAR_OP_DEC ){
+                    op = StreamDPVmInstructions::ditDEC64 ;
+                }
+
+                if ( lpMan->m_op == StreamVmInstructionFlowMan::FLOW_VAR_OP_RANDOM ){
+                    op = StreamDPVmInstructions::ditRANDOM64 ;
+                }
+
+                StreamDPOpFlowVar32 fv64;
+                fv64.m_op = op;
+                fv64.m_flow_offset = get_var_offset(lpMan->m_var_name);
+                fv64.m_min_val     = (uint64_t)lpMan->m_min_value;
+                fv64.m_max_val     = (uint64_t)lpMan->m_max_value;
+                m_instructions.add_command(&fv64,sizeof(fv64));
+            }
+        }
+
+        if (ins_type == StreamVmInstruction::itPKT_WR) {
+            StreamVmInstructionWriteToPkt *lpPkt =(StreamVmInstructionWriteToPkt *)inst;
+
+            VmFlowVarRec var;
+            if ( var_lookup(lpPkt->m_flow_var_name ,var) == false){
+
+                std::stringstream ss;
+                ss << "instruction id '" << ins_id << "' packet write with no valid flow varible name '" << lpPkt->m_flow_var_name << "'" ;
+                err(ss.str());
+            }
+
+            if (lpPkt->m_pkt_offset + var.m_size_bytes > m_pkt_size ) {
+                std::stringstream ss;
+                ss << "instruction id '" << ins_id << "' packet write with packet_offset   " << lpPkt->m_pkt_offset + var.m_size_bytes  << "   bigger than packet size   "<< m_pkt_size;
+                err(ss.str());
+            }
+            add_field_cnt(lpPkt->m_pkt_offset + var.m_size_bytes);
+
+
+            uint8_t       op_size=var.m_size_bytes;
+            bool is_big    = lpPkt->m_is_big_endian;
+            uint8_t       flags = (is_big?StreamDPOpPktWrBase::PKT_WR_IS_BIG:0);
+            uint8_t       flow_offset = get_var_offset(lpPkt->m_flow_var_name);
+
+            if (op_size == 1) {
+                StreamDPOpPktWr8 pw8;
+                pw8.m_op = StreamDPVmInstructions::itPKT_WR8;
+                pw8.m_flags =flags;
+                pw8.m_offset =flow_offset;
+                pw8.m_pkt_offset = lpPkt->m_pkt_offset;
+                pw8.m_val_offset = (int8_t)lpPkt->m_add_value;
+                m_instructions.add_command(&pw8,sizeof(pw8));
+            }
+
+            if (op_size == 2) {
+                StreamDPOpPktWr16 pw16;
+                pw16.m_op = StreamDPVmInstructions::itPKT_WR16;
+                pw16.m_flags =flags;
+                pw16.m_offset =flow_offset;
+                pw16.m_pkt_offset = lpPkt->m_pkt_offset;
+                pw16.m_val_offset = (int16_t)lpPkt->m_add_value;
+                m_instructions.add_command(&pw16,sizeof(pw16));
+            }
+
+            if (op_size == 4) {
+                StreamDPOpPktWr32 pw32;
+                pw32.m_op = StreamDPVmInstructions::itPKT_WR32;
+                pw32.m_flags =flags;
+                pw32.m_offset =flow_offset;
+                pw32.m_pkt_offset = lpPkt->m_pkt_offset;
+                pw32.m_val_offset = (int32_t)lpPkt->m_add_value;
+                m_instructions.add_command(&pw32,sizeof(pw32));
+            }
+
+            if (op_size == 8) {
+                StreamDPOpPktWr64 pw64;
+                pw64.m_op = StreamDPVmInstructions::itPKT_WR64;
+                pw64.m_flags =flags;
+                pw64.m_offset =flow_offset;
+                pw64.m_pkt_offset = lpPkt->m_pkt_offset;
+                pw64.m_val_offset = (int64_t)lpPkt->m_add_value;
+                m_instructions.add_command(&pw64,sizeof(pw64));
+            }
+
+        }
+
+
+        if (ins_type == StreamVmInstruction::itFLOW_CLIENT) {
+            StreamVmInstructionFlowClient *lpMan =(StreamVmInstructionFlowClient *)inst;
+
+            if ( lpMan->is_unlimited_flows() ){
+                StreamDPOpClientsUnLimit  client_cmd;
+                client_cmd.m_op =  StreamDPVmInstructions::itCLIENT_VAR_UNLIMIT;
+
+                client_cmd.m_flow_offset = get_var_offset(lpMan->m_var_name+".ip"); /* start offset */
+                client_cmd.m_flags       = 0; /* not used */
+                client_cmd.m_pad         = 0;
+                client_cmd.m_min_ip      = lpMan->m_client_min;
+                client_cmd.m_max_ip      = lpMan->m_client_max;
+                m_instructions.add_command(&client_cmd,sizeof(client_cmd));
+
+            }else{
+                StreamDPOpClientsLimit  client_cmd;
+                client_cmd.m_op =  StreamDPVmInstructions::itCLIENT_VAR;
+
+                client_cmd.m_flow_offset = get_var_offset(lpMan->m_var_name+".ip"); /* start offset */
+                client_cmd.m_flags       = 0; /* not used */
+                client_cmd.m_pad         = 0;
+                client_cmd.m_min_port    = lpMan->m_port_min;
+                client_cmd.m_max_port    = lpMan->m_port_max;
+                client_cmd.m_min_ip      = lpMan->m_client_min;
+                client_cmd.m_max_ip      = lpMan->m_client_max;
+                client_cmd.m_limit_flows = lpMan->m_limit_num_flows;
+                m_instructions.add_command(&client_cmd,sizeof(client_cmd));
+            }
+        }
+
+        ins_id++;
+    }
+}
+
+
+void StreamVm::build_bss() {
+    alloc_bss();
+    uint8_t * p=(uint8_t *)m_bss;
+
+    for (auto inst : m_inst_list) {
+
+        if ( inst->get_instruction_type() == StreamVmInstruction::itFLOW_MAN ){
+
+            StreamVmInstructionFlowMan * ins_man=(StreamVmInstructionFlowMan *)inst;
+
+            switch (ins_man->m_size_bytes) {
+            case 1:
+                *p=(uint8_t)ins_man->m_init_value;
+                p+=1;
+                break;
+            case 2:
+                *((uint16_t*)p)=(uint16_t)ins_man->m_init_value;
+                p+=2;
+                break;
+            case 4:
+                *((uint32_t*)p)=(uint32_t)ins_man->m_init_value;
+                p+=4;
+                break;
+            case 8:
+                *((uint64_t*)p)=(uint64_t)ins_man->m_init_value;
+                p+=8;
+                break;
+            default:
+                assert(0);
+            }
+        }
+
+        if ( inst->get_instruction_type() == StreamVmInstruction::itFLOW_CLIENT ){
+
+            StreamVmInstructionFlowClient * ins_man=(StreamVmInstructionFlowClient *)inst;
+            if (ins_man->m_client_min>0) {
+                *((uint32_t*)p)=(uint32_t)(ins_man->m_client_min-1);
+            }else{
+                *((uint32_t*)p)=(uint32_t)ins_man->m_client_min;
+            }
+            p+=4;
+
+            if (ins_man->is_unlimited_flows() ) {
+                *((uint16_t*)p)=StreamDPOpClientsUnLimit::CLIENT_UNLIMITED_MIN_PORT;
+            }else{
+                *((uint16_t*)p)=(uint16_t)ins_man->m_port_min;
+            }
+            p+=2;
+
+            *((uint32_t*)p)=0;
+            p+=4;
+        }
+
+    }
+}
+
+
+
+void StreamVm::compile() {
+
+    /* build flow var offset table */
+    build_flow_var_table() ;
+
+    /* build init flow var memory */
+    build_bss();
+
+    build_program();
+
+    if ( get_max_packet_update_offset() >svMAX_PACKET_OFFSET_CHANGE ){
+        std::stringstream ss;
+        ss << "maximum offset is" << get_max_packet_update_offset() << " bigger than maximum " <<svMAX_PACKET_OFFSET_CHANGE;
+        err(ss.str());
+    }
 }
 
+
 StreamVm::~StreamVm() {
     for (auto inst : m_inst_list) {
         delete inst;
+    }          
+    free_bss();
+}
+
+
+void StreamVm::Dump(FILE *fd){
+    fprintf(fd," instructions \n");
+    uint32_t cnt=0;
+    for (auto inst : m_inst_list) {
+        fprintf(fd," [%04lu]   : ",(ulong)cnt);
+        inst->Dump(fd);
+        cnt++;
     }
+
+    if ( get_bss_size() ) {
+        fprintf(fd," BSS  size %lu\n",(ulong)get_bss_size());
+        utl_DumpBuffer(fd,get_bss_ptr(),get_bss_size(),0);
+    }
+
+    if  ( m_instructions.get_program_size() > 0 ){
+        fprintf(fd," RAW instructions \n");
+        m_instructions.Dump(fd);
+    }
+}
+
+
+void StreamDPVmInstructions::clear(){
+    m_inst_list.clear();
+}
+
+
+void StreamDPVmInstructions::add_command(void *buffer,uint16_t size){
+    int i;
+    uint8_t *p= (uint8_t *)buffer;
+    /* push byte by byte */
+    for (i=0; i<size; i++) {
+        m_inst_list.push_back(*p);
+        p++;
+    }
+}
+
+uint8_t * StreamDPVmInstructions::get_program(){
+    return (&m_inst_list[0]);
+}
+
+uint32_t StreamDPVmInstructions::get_program_size(){
+    return (m_inst_list.size());
+}
+
+void StreamDPVmInstructions::Dump(FILE *fd){
+
+    uint8_t * p=get_program();
+
+
+    uint32_t program_size = get_program_size();
+    uint8_t * p_end=p+program_size;
+
+    StreamDPOpFlowVar8  *lpv8;
+    StreamDPOpFlowVar16 *lpv16;
+    StreamDPOpFlowVar32 *lpv32;
+    StreamDPOpFlowVar64 *lpv64;
+    StreamDPOpIpv4Fix   *lpIpv4Fix;
+    StreamDPOpPktWr8     *lpw8;
+    StreamDPOpPktWr16    *lpw16;
+    StreamDPOpPktWr32    *lpw32;
+    StreamDPOpPktWr64    *lpw64;
+    StreamDPOpClientsLimit   *lp_client;
+    StreamDPOpClientsUnLimit  *lp_client_unlimited;
+
+
+    while ( p < p_end) {
+        uint8_t op_code=*p;
+        switch (op_code) {
+
+        case   ditINC8  :
+            lpv8 =(StreamDPOpFlowVar8 *)p;
+            lpv8->dump(fd,"INC8");
+            p+=sizeof(StreamDPOpFlowVar8);
+            break;
+        case  ditINC16  :
+            lpv16 =(StreamDPOpFlowVar16 *)p;
+            lpv16->dump(fd,"INC16");
+            p+=sizeof(StreamDPOpFlowVar16);
+            break;
+        case  ditINC32 :
+            lpv32 =(StreamDPOpFlowVar32 *)p;
+            lpv32->dump(fd,"INC32");
+            p+=sizeof(StreamDPOpFlowVar32);
+             break;
+        case  ditINC64 :
+            lpv64 =(StreamDPOpFlowVar64 *)p;
+            lpv64->dump(fd,"INC64");
+            p+=sizeof(StreamDPOpFlowVar64);
+            break;
+
+        case  ditDEC8 :
+            lpv8 =(StreamDPOpFlowVar8 *)p;
+            lpv8->dump(fd,"DEC8");
+            p+=sizeof(StreamDPOpFlowVar8);
+            break;
+        case  ditDEC16 :
+            lpv16 =(StreamDPOpFlowVar16 *)p;
+            lpv16->dump(fd,"DEC16");
+            p+=sizeof(StreamDPOpFlowVar16);
+            break;
+        case  ditDEC32 :
+            lpv32 =(StreamDPOpFlowVar32 *)p;
+            lpv32->dump(fd,"DEC32");
+            p+=sizeof(StreamDPOpFlowVar32);
+            break;
+        case  ditDEC64 :
+            lpv64 =(StreamDPOpFlowVar64 *)p;
+            lpv64->dump(fd,"DEC64");
+            p+=sizeof(StreamDPOpFlowVar64);
+            break;
+
+        case  ditRANDOM8 :
+            lpv8 =(StreamDPOpFlowVar8 *)p;
+            lpv8->dump(fd,"RAND8");
+            p+=sizeof(StreamDPOpFlowVar8);
+            break;
+        case  ditRANDOM16 :
+            lpv16 =(StreamDPOpFlowVar16 *)p;
+            lpv16->dump(fd,"RAND16");
+            p+=sizeof(StreamDPOpFlowVar16);
+            break;
+        case  ditRANDOM32 :
+            lpv32 =(StreamDPOpFlowVar32 *)p;
+            lpv32->dump(fd,"RAND32");
+            p+=sizeof(StreamDPOpFlowVar32);
+            break;
+        case  ditRANDOM64 :
+            lpv64 =(StreamDPOpFlowVar64 *)p;
+            lpv64->dump(fd,"RAND64");
+            p+=sizeof(StreamDPOpFlowVar64);
+            break;
+
+        case  ditFIX_IPV4_CS :
+            lpIpv4Fix =(StreamDPOpIpv4Fix *)p;
+            lpIpv4Fix->dump(fd,"Ipv4Fix");
+            p+=sizeof(StreamDPOpIpv4Fix);
+            break;
+
+        case  itPKT_WR8  :
+            lpw8 =(StreamDPOpPktWr8 *)p;
+            lpw8->dump(fd,"Wr8");
+            p+=sizeof(StreamDPOpPktWr8);
+            break;
+
+        case  itPKT_WR16 :
+            lpw16 =(StreamDPOpPktWr16 *)p;
+            lpw16->dump(fd,"Wr16");
+            p+=sizeof(StreamDPOpPktWr16);
+            break;
+
+        case  itPKT_WR32 :
+            lpw32 =(StreamDPOpPktWr32 *)p;
+            lpw32->dump(fd,"Wr32");
+            p+=sizeof(StreamDPOpPktWr32);
+            break;
+
+        case  itPKT_WR64 :      
+            lpw64 =(StreamDPOpPktWr64 *)p;
+            lpw64->dump(fd,"Wr64");
+            p+=sizeof(StreamDPOpPktWr64);
+            break;
+
+        case  itCLIENT_VAR :      
+            lp_client =(StreamDPOpClientsLimit *)p;
+            lp_client->dump(fd,"Client");
+            p+=sizeof(StreamDPOpClientsLimit);
+            break;
+
+        case  itCLIENT_VAR_UNLIMIT :      
+            lp_client_unlimited =(StreamDPOpClientsUnLimit *)p;
+            lp_client_unlimited->dump(fd,"ClientUnlimted");
+            p+=sizeof(StreamDPOpClientsUnLimit);
+            break;
+
+
+        default:
+            assert(0);
+        }
+    };
+}
+
+
+void StreamDPOpFlowVar8::dump(FILE *fd,std::string opt){
+    fprintf(fd," %10s  op:%lu, of:%lu, (%lu- %lu) \n",  opt.c_str(),(ulong)m_op,(ulong)m_flow_offset,(ulong)m_min_val,(ulong)m_max_val);
+}
+
+void StreamDPOpFlowVar16::dump(FILE *fd,std::string opt){
+    fprintf(fd," %10s  op:%lu, of:%lu, (%lu-%lu) \n",  opt.c_str(),(ulong)m_op,(ulong)m_flow_offset,(ulong)m_min_val,(ulong)m_max_val);
+}
+
+void StreamDPOpFlowVar32::dump(FILE *fd,std::string opt){
+    fprintf(fd," %10s  op:%lu, of:%lu, (%lu-%lu) \n",  opt.c_str(),(ulong)m_op,(ulong)m_flow_offset,(ulong)m_min_val,(ulong)m_max_val);
+}
+
+void StreamDPOpFlowVar64::dump(FILE *fd,std::string opt){
+    fprintf(fd," %10s  op:%lu, of:%lu, (%lu-%lu) \n",  opt.c_str(),(ulong)m_op,(ulong)m_flow_offset,(ulong)m_min_val,(ulong)m_max_val);
+}
+
+void StreamDPOpPktWr8::dump(FILE *fd,std::string opt){
+    fprintf(fd," %10s  op:%lu, flags:%lu, pkt_of:%lu,  f_of:%lu \n",  opt.c_str(),(ulong)m_op,(ulong)m_flags,(ulong)m_pkt_offset,(ulong)m_offset);
 }
 
+void StreamDPOpPktWr16::dump(FILE *fd,std::string opt){
+    fprintf(fd," %10s  op:%lu, flags:%lu, pkt_of:%lu , f_of:%lu \n",  opt.c_str(),(ulong)m_op,(ulong)m_flags,(ulong)m_pkt_offset,(ulong)m_offset);
+}
+
+void StreamDPOpPktWr32::dump(FILE *fd,std::string opt){
+    fprintf(fd," %10s  op:%lu, flags:%lu, pkt_of:%lu , f_of:%lu \n",  opt.c_str(),(ulong)m_op,(ulong)m_flags,(ulong)m_pkt_offset,(ulong)m_offset);
+}
+
+void StreamDPOpPktWr64::dump(FILE *fd,std::string opt){
+    fprintf(fd," %10s  op:%lu, flags:%lu, pkt_of:%lu , f_of:%lu \n",  opt.c_str(),(ulong)m_op,(ulong)m_flags,(ulong)m_pkt_offset,(ulong)m_offset);
+}
+
+
+void StreamDPOpIpv4Fix::dump(FILE *fd,std::string opt){
+    fprintf(fd," %10s  op:%lu, offset: %lu \n",  opt.c_str(),(ulong)m_op,(ulong)m_offset);
+}
+
+
+void StreamDPOpClientsLimit::dump(FILE *fd,std::string opt){
+    fprintf(fd," %10s  op:%lu, flow_offset: %lu (%x-%x) (%x-%x) flow_limit :%lu flags:%x \n",  opt.c_str(),(ulong)m_op,(ulong)m_flow_offset,m_min_ip,m_max_ip,m_min_port,m_max_port,(ulong)m_limit_flows,m_flags);
+}
+
+void StreamDPOpClientsUnLimit::dump(FILE *fd,std::string opt){
+    fprintf(fd," %10s  op:%lu, flow_offset: %lu (%x-%x) flags:%x \n",  opt.c_str(),(ulong)m_op,(ulong)m_flow_offset,m_min_ip,m_max_ip,m_flags);
+}
+
+
diff --git a/src/stateless/cp/trex_stream_vm.h b/src/stateless/cp/trex_stream_vm.h
index 56edbcaf..e65a87e3 100644
--- a/src/stateless/cp/trex_stream_vm.h
+++ b/src/stateless/cp/trex_stream_vm.h
@@ -24,6 +24,526 @@ limitations under the License.
 #include <string>
 #include <stdint.h>
 #include <vector>
+#include <unordered_map>
+#include <assert.h>
+#include <common/Network/Packet/IPHeader.h>
+#include "pal_utl.h"
+#include "mbuf.h"
+
+
+
+
+class StreamVm;
+
+
+/* in memory program */
+
+struct StreamDPOpFlowVar8 {
+    uint8_t m_op;
+    uint8_t m_flow_offset;
+    uint8_t m_min_val;
+    uint8_t m_max_val;
+public:
+    void dump(FILE *fd,std::string opt);
+
+    inline void run_inc(uint8_t * flow_var) {
+        uint8_t * p=(flow_var+m_flow_offset);
+        *p=*p+1;
+        if (*p>m_max_val) {
+            *p=m_min_val;
+        }
+    }
+
+    inline void run_dec(uint8_t * flow_var) {
+        uint8_t * p=(flow_var+m_flow_offset);
+        *p=*p-1;
+        if (*p<m_min_val) {
+            *p=m_max_val;
+        }
+    }
+
+    inline void run_rand(uint8_t * flow_var) {
+        uint8_t * p=(flow_var+m_flow_offset);
+        *p= m_min_val + (rand() % (int)(m_max_val - m_min_val + 1));
+    }
+
+
+} __attribute__((packed)) ;
+
+struct StreamDPOpFlowVar16 {
+    uint8_t m_op;
+    uint8_t m_flow_offset;
+    uint16_t m_min_val;
+    uint16_t m_max_val;
+public:
+    void dump(FILE *fd,std::string opt);
+
+    inline void run_inc(uint8_t * flow_var) {
+        uint16_t * p=(uint16_t *)(flow_var+m_flow_offset);
+        *p=*p+1;
+        if (*p>m_max_val) {
+            *p=m_min_val;
+        }
+    }
+
+    inline void run_dec(uint8_t * flow_var) {
+        uint16_t * p=(uint16_t *)(flow_var+m_flow_offset);
+        *p=*p-1;
+        if (*p<m_min_val) {
+            *p=m_max_val;
+        }
+    }
+
+    inline void run_rand(uint8_t * flow_var) {
+        uint16_t * p=(uint16_t *)(flow_var+m_flow_offset);
+        *p= m_min_val + (rand() % (int)(m_max_val - m_min_val + 1));
+    }
+
+
+
+} __attribute__((packed)) ;
+
+struct StreamDPOpFlowVar32 {
+    uint8_t m_op;
+    uint8_t m_flow_offset;
+    uint32_t m_min_val;
+    uint32_t m_max_val;
+public:
+    void dump(FILE *fd,std::string opt);
+
+    inline void run_inc(uint8_t * flow_var) {
+        uint32_t * p=(uint32_t *)(flow_var+m_flow_offset);
+        *p=*p+1;
+        if (*p>m_max_val) {
+            *p=m_min_val;
+        }
+    }
+
+    inline void run_dec(uint8_t * flow_var) {
+        uint32_t * p=(uint32_t *)(flow_var+m_flow_offset);
+        *p=*p-1;
+        if (*p<m_min_val) {
+            *p=m_max_val;
+        }
+    }
+
+    inline void run_rand(uint8_t * flow_var) {
+        uint32_t * p=(uint32_t *)(flow_var+m_flow_offset);
+        *p= m_min_val + (rand() % (int)(m_max_val - m_min_val + 1));
+    }
+
+} __attribute__((packed)) ;
+
+struct StreamDPOpFlowVar64 {
+    uint8_t m_op;
+    uint8_t m_flow_offset;
+    uint64_t m_min_val;
+    uint64_t m_max_val;
+public:
+    void dump(FILE *fd,std::string opt);
+
+    inline void run_inc(uint8_t * flow_var) {
+        uint64_t * p=(uint64_t *)(flow_var+m_flow_offset);
+        *p=*p+1;
+        if (*p>m_max_val) {
+            *p=m_min_val;
+        }
+    }
+
+    inline void run_dec(uint8_t * flow_var) {
+        uint64_t * p=(uint64_t *)(flow_var+m_flow_offset);
+        *p=*p-1;
+        if (*p<m_min_val) {
+            *p=m_max_val;
+        }
+    }
+
+    inline void run_rand(uint8_t * flow_var) {
+        uint64_t * p=(uint64_t *)(flow_var+m_flow_offset);
+        *p= m_min_val + (rand() % (int)(m_max_val - m_min_val + 1));
+    }
+
+
+} __attribute__((packed)) ;
+
+
+struct StreamDPOpPktWrBase {
+    enum {
+        PKT_WR_IS_BIG = 1
+    }; /* for flags */
+
+    uint8_t m_op;
+    uint8_t m_flags;
+    uint8_t  m_offset; 
+
+public:
+    bool is_big(){
+        return ( (m_flags &StreamDPOpPktWrBase::PKT_WR_IS_BIG) == StreamDPOpPktWrBase::PKT_WR_IS_BIG ?true:false);
+    }
+
+} __attribute__((packed)) ;
+
+
+struct StreamDPOpPktWr8 : public StreamDPOpPktWrBase {
+    int8_t  m_val_offset;
+    uint16_t m_pkt_offset;
+
+public:
+    void dump(FILE *fd,std::string opt);
+
+    inline void wr(uint8_t * flow_var_base,uint8_t * pkt_base) {
+        uint8_t * p_pkt      = (pkt_base+m_pkt_offset);
+        uint8_t * p_flow_var = (flow_var_base+m_offset);
+        *p_pkt=(*p_flow_var+m_val_offset);
+
+    }
+
+
+} __attribute__((packed)) ;
+
+
+struct StreamDPOpPktWr16 : public StreamDPOpPktWrBase {
+    uint16_t m_pkt_offset;
+    int16_t  m_val_offset;
+public:
+    void dump(FILE *fd,std::string opt);
+
+    inline void wr(uint8_t * flow_var_base,uint8_t * pkt_base) {
+        uint16_t * p_pkt      = (uint16_t*)(pkt_base+m_pkt_offset);
+        uint16_t * p_flow_var = (uint16_t*)(flow_var_base+m_offset);
+
+        if ( likely(is_big())){
+            *p_pkt=PKT_HTONS((*p_flow_var+m_val_offset));
+        }else{
+            *p_pkt=(*p_flow_var+m_val_offset);
+        }
+
+    }
+} __attribute__((packed));
+
+struct StreamDPOpPktWr32 : public StreamDPOpPktWrBase {
+    uint16_t m_pkt_offset;
+    int32_t  m_val_offset;
+public:
+    void dump(FILE *fd,std::string opt);
+
+    inline void wr(uint8_t * flow_var_base,uint8_t * pkt_base) {
+        uint32_t * p_pkt      = (uint32_t*)(pkt_base+m_pkt_offset);
+        uint32_t * p_flow_var = (uint32_t*)(flow_var_base+m_offset);
+        if ( likely(is_big())){
+            *p_pkt=PKT_HTONL((*p_flow_var+m_val_offset));
+        }else{
+            *p_pkt=(*p_flow_var+m_val_offset);
+        }
+    }
+
+} __attribute__((packed));
+
+struct StreamDPOpPktWr64 : public StreamDPOpPktWrBase {
+    uint16_t m_pkt_offset;
+    int64_t  m_val_offset;
+
+public:
+    void dump(FILE *fd,std::string opt);
+
+    inline void wr(uint8_t * flow_var_base,uint8_t * pkt_base) {
+        uint64_t * p_pkt      = (uint64_t*)(pkt_base+m_pkt_offset);
+        uint64_t * p_flow_var = (uint64_t*)(flow_var_base+m_offset);
+        if ( likely(is_big())){
+            *p_pkt=pal_ntohl64((*p_flow_var+m_val_offset));
+        }else{
+            *p_pkt=(*p_flow_var+m_val_offset);
+        }
+    }
+
+
+} __attribute__((packed));
+
+struct StreamDPOpIpv4Fix {
+    uint8_t m_op;
+    uint16_t  m_offset;
+public:
+    void dump(FILE *fd,std::string opt);
+    void run(uint8_t * pkt_base){
+        IPHeader *      ipv4=  (IPHeader *)(pkt_base+m_offset);
+        ipv4->updateCheckSum();
+    }
+
+} __attribute__((packed));
+
+
+/* flow varible of Client command */
+struct StreamDPFlowClient {
+    uint32_t cur_ip;
+    uint16_t cur_port;
+    uint32_t cur_flow_id;
+} __attribute__((packed));
+
+
+struct StreamDPOpClientsLimit {
+    uint8_t m_op;
+    uint8_t m_flow_offset; /* offset into the flow var  bytes */
+    uint8_t m_flags;
+    uint8_t m_pad;
+    uint16_t    m_min_port;
+    uint16_t    m_max_port;
+
+    uint32_t    m_min_ip;
+    uint32_t    m_max_ip;
+    uint32_t    m_limit_flows; /* limit the number of flows */
+
+public:
+    void dump(FILE *fd,std::string opt);
+    inline void run(uint8_t * flow_var_base) {
+        StreamDPFlowClient * lp= (StreamDPFlowClient *)(flow_var_base+m_flow_offset);
+        lp->cur_ip++;
+        if (lp->cur_ip > m_max_ip ) {
+            lp->cur_ip= m_min_ip;
+            lp->cur_port++;
+            if (lp->cur_port > m_max_port) {
+                lp->cur_port = m_min_port;
+            }
+        }
+
+        if (m_limit_flows) {
+            lp->cur_flow_id++;
+            if ( lp->cur_flow_id > m_limit_flows ){
+                /* reset to the first flow */
+                lp->cur_flow_id = 1;
+                lp->cur_ip      =  m_min_ip;
+                lp->cur_port    =  m_min_port;
+            }
+        }
+    }
+
+
+} __attribute__((packed));
+
+struct StreamDPOpClientsUnLimit {
+    enum __MIN_PORT {
+        CLIENT_UNLIMITED_MIN_PORT = 1025
+    };
+
+    uint8_t m_op;
+    uint8_t m_flow_offset; /* offset into the flow var  bytes */
+    uint8_t m_flags;
+    uint8_t m_pad;
+    uint32_t    m_min_ip;
+    uint32_t    m_max_ip;
+
+public:
+    void dump(FILE *fd,std::string opt);
+    inline void run(uint8_t * flow_var_base) {
+        StreamDPFlowClient * lp= (StreamDPFlowClient *)(flow_var_base+m_flow_offset);
+        lp->cur_ip++;
+        if (lp->cur_ip > m_max_ip ) {
+            lp->cur_ip= m_min_ip;
+            lp->cur_port++;
+            if (lp->cur_port == 0) {
+                lp->cur_port = StreamDPOpClientsUnLimit::CLIENT_UNLIMITED_MIN_PORT;
+            }
+        }
+    }
+
+} __attribute__((packed));
+
+
+/* datapath instructions */
+class StreamDPVmInstructions {
+public:
+    enum INS_TYPE {
+        ditINC8         ,
+        ditINC16        ,
+        ditINC32        ,
+        ditINC64        ,
+
+        ditDEC8         ,
+        ditDEC16        ,
+        ditDEC32        ,
+        ditDEC64        ,
+
+        ditRANDOM8      ,
+        ditRANDOM16     ,
+        ditRANDOM32     ,
+        ditRANDOM64     ,
+
+        ditFIX_IPV4_CS  ,
+
+        itPKT_WR8       ,
+        itPKT_WR16       ,
+        itPKT_WR32       ,
+        itPKT_WR64       ,
+        itCLIENT_VAR       ,
+        itCLIENT_VAR_UNLIMIT      
+    };
+
+
+public:
+    void clear();
+    void add_command(void *buffer,uint16_t size);
+    uint8_t * get_program();
+    uint32_t get_program_size();
+
+
+    void Dump(FILE *fd);
+
+
+private:
+    std::vector<uint8_t> m_inst_list;
+};
+
+
+class StreamDPVmInstructionsRunner {
+public:
+    inline void run(uint32_t program_size,
+                    uint8_t * program,  /* program */
+                    uint8_t * flow_var, /* flow var */
+                    uint8_t * pkt);      /* pkt */
+
+};
+
+
+inline void StreamDPVmInstructionsRunner::run(uint32_t program_size,
+                                              uint8_t * program,  /* program */
+                                              uint8_t * flow_var, /* flow var */
+                                              uint8_t * pkt){
+
+
+    uint8_t * p=program;
+    uint8_t * p_end=p+program_size;
+
+
+    union  ua_ {
+        StreamDPOpFlowVar8  *lpv8;
+        StreamDPOpFlowVar16 *lpv16;
+        StreamDPOpFlowVar32 *lpv32;
+        StreamDPOpFlowVar64 *lpv64;
+        StreamDPOpIpv4Fix   *lpIpv4Fix;
+        StreamDPOpPktWr8     *lpw8;
+        StreamDPOpPktWr16    *lpw16;
+        StreamDPOpPktWr32    *lpw32;
+        StreamDPOpPktWr64    *lpw64;
+        StreamDPOpClientsLimit      *lpcl;
+        StreamDPOpClientsUnLimit    *lpclu;
+    } ua ;
+
+    while ( p < p_end) {
+        uint8_t op_code=*p;
+        switch (op_code) {
+
+        case  StreamDPVmInstructions::itCLIENT_VAR :      
+            ua.lpcl =(StreamDPOpClientsLimit *)p;
+            ua.lpcl->run(flow_var);
+            p+=sizeof(StreamDPOpClientsLimit);
+            break;
+
+        case  StreamDPVmInstructions::itCLIENT_VAR_UNLIMIT :      
+            ua.lpclu =(StreamDPOpClientsUnLimit *)p;
+            ua.lpclu->run(flow_var);
+            p+=sizeof(StreamDPOpClientsUnLimit);
+            break;
+
+        case   StreamDPVmInstructions::ditINC8  :
+            ua.lpv8 =(StreamDPOpFlowVar8 *)p;
+            ua.lpv8->run_inc(flow_var);
+            p+=sizeof(StreamDPOpFlowVar8);
+            break;
+
+        case  StreamDPVmInstructions::ditINC16  :
+            ua.lpv16 =(StreamDPOpFlowVar16 *)p;
+            ua.lpv16->run_inc(flow_var);
+            p+=sizeof(StreamDPOpFlowVar16);
+            break;
+        case  StreamDPVmInstructions::ditINC32 :
+            ua.lpv32 =(StreamDPOpFlowVar32 *)p;
+            ua.lpv32->run_inc(flow_var);
+            p+=sizeof(StreamDPOpFlowVar32);
+             break;
+        case  StreamDPVmInstructions::ditINC64 :
+            ua.lpv64 =(StreamDPOpFlowVar64 *)p;
+            ua.lpv64->run_inc(flow_var);
+            p+=sizeof(StreamDPOpFlowVar64);
+            break;
+
+        case  StreamDPVmInstructions::ditDEC8 :
+            ua.lpv8 =(StreamDPOpFlowVar8 *)p;
+            ua.lpv8->run_dec(flow_var);
+            p+=sizeof(StreamDPOpFlowVar8);
+            break;
+        case  StreamDPVmInstructions::ditDEC16 :
+            ua.lpv16 =(StreamDPOpFlowVar16 *)p;
+            ua.lpv16->run_dec(flow_var);
+            p+=sizeof(StreamDPOpFlowVar16);
+            break;
+        case  StreamDPVmInstructions::ditDEC32 :
+            ua.lpv32 =(StreamDPOpFlowVar32 *)p;
+            ua.lpv32->run_dec(flow_var);
+            p+=sizeof(StreamDPOpFlowVar32);
+            break;
+        case  StreamDPVmInstructions::ditDEC64 :
+            ua.lpv64 =(StreamDPOpFlowVar64 *)p;
+            ua.lpv64->run_dec(flow_var);
+            p+=sizeof(StreamDPOpFlowVar64);
+            break;
+
+        case  StreamDPVmInstructions::ditRANDOM8 :
+            ua.lpv8 =(StreamDPOpFlowVar8 *)p;
+            ua.lpv8->run_rand(flow_var);
+            p+=sizeof(StreamDPOpFlowVar8);
+            break;
+        case  StreamDPVmInstructions::ditRANDOM16 :
+            ua.lpv16 =(StreamDPOpFlowVar16 *)p;
+            ua.lpv16->run_rand(flow_var);
+            p+=sizeof(StreamDPOpFlowVar16);
+            break;
+        case  StreamDPVmInstructions::ditRANDOM32 :
+            ua.lpv32 =(StreamDPOpFlowVar32 *)p;
+            ua.lpv32->run_rand(flow_var);
+            p+=sizeof(StreamDPOpFlowVar32);
+            break;
+        case  StreamDPVmInstructions::ditRANDOM64 :
+            ua.lpv64 =(StreamDPOpFlowVar64 *)p;
+            ua.lpv64->run_rand(flow_var);
+            p+=sizeof(StreamDPOpFlowVar64);
+            break;
+
+        case  StreamDPVmInstructions::ditFIX_IPV4_CS :
+            ua.lpIpv4Fix =(StreamDPOpIpv4Fix *)p;
+            ua.lpIpv4Fix->run(pkt);
+            p+=sizeof(StreamDPOpIpv4Fix);
+            break;
+
+        case  StreamDPVmInstructions::itPKT_WR8  :
+            ua.lpw8 =(StreamDPOpPktWr8 *)p;
+            ua.lpw8->wr(flow_var,pkt);
+            p+=sizeof(StreamDPOpPktWr8);
+            break;
+
+        case  StreamDPVmInstructions::itPKT_WR16 :
+            ua.lpw16 =(StreamDPOpPktWr16 *)p;
+            ua.lpw16->wr(flow_var,pkt);
+            p+=sizeof(StreamDPOpPktWr16);
+            break;
+
+        case  StreamDPVmInstructions::itPKT_WR32 :
+            ua.lpw32 =(StreamDPOpPktWr32 *)p;
+            ua.lpw32->wr(flow_var,pkt);
+            p+=sizeof(StreamDPOpPktWr32);
+            break;
+
+        case  StreamDPVmInstructions::itPKT_WR64 :      
+            ua.lpw64 =(StreamDPOpPktWr64 *)p;
+            ua.lpw64->wr(flow_var,pkt);
+            p+=sizeof(StreamDPOpPktWr64);
+            break;
+        default:
+            assert(0);
+        }
+    };
+};
+
+
+
 
 /**
  * interface for stream VM instruction
@@ -32,8 +552,24 @@ limitations under the License.
 class StreamVmInstruction {
 public:
 
+    enum INS_TYPE {
+        itNONE         = 0,
+        itFIX_IPV4_CS  = 4,
+        itFLOW_MAN     = 5,
+        itPKT_WR       = 6,
+        itFLOW_CLIENT  = 7 
+
+    };
+
+    typedef uint8_t instruction_type_t ;
+
+    virtual instruction_type_t get_instruction_type()=0;
+
     virtual ~StreamVmInstruction();
 
+    virtual void Dump(FILE *fd)=0;
+    
+
 private:
     static const std::string m_name;
 };
@@ -48,8 +584,14 @@ public:
 
     }
 
-private:
-    uint16_t m_pkt_offset;
+    virtual instruction_type_t get_instruction_type(){
+        return ( StreamVmInstruction::itFIX_IPV4_CS);
+    }
+
+    virtual void Dump(FILE *fd);
+
+public:
+    uint16_t m_pkt_offset; /* the offset of IPv4 header from the start of the packet  */
 };
 
 /**
@@ -61,6 +603,10 @@ class StreamVmInstructionFlowMan : public StreamVmInstruction {
 
 public:
 
+    virtual instruction_type_t get_instruction_type(){
+        return ( StreamVmInstruction::itFLOW_MAN);
+    }
+
     /**
      * different types of operations on the object
      */
@@ -85,7 +631,16 @@ public:
 
     }
 
+    virtual void Dump(FILE *fd);
+
+    void sanity_check(uint32_t ins_id,StreamVm *lp);
+
 private:
+    void sanity_check_valid_range(uint32_t ins_id,StreamVm *lp);
+    void sanity_check_valid_size(uint32_t ins_id,StreamVm *lp);
+    void sanity_check_valid_opt(uint32_t ins_id,StreamVm *lp);
+
+public:
 
 
     /* flow var name */
@@ -105,6 +660,83 @@ private:
 
 };
 
+
+/**
+ * flow client instruction - save state for client range and port range 
+ * 
+ * @author hhaim
+ */
+class StreamVmInstructionFlowClient : public StreamVmInstruction {
+
+public:
+    enum client_flags_e {
+        CLIENT_F_UNLIMITED_FLOWS=1, /* unlimited number of flow, don't care about ports  */
+    };
+
+
+    virtual instruction_type_t get_instruction_type(){
+        return ( StreamVmInstruction::itFLOW_CLIENT);
+    }
+
+
+    StreamVmInstructionFlowClient(const std::string &var_name,
+                               uint32_t client_min_value,
+                               uint32_t client_max_value,
+                               uint16_t port_min,
+                               uint16_t port_max,
+                               uint32_t limit_num_flows, /* zero means don't limit */
+                               uint16_t flags
+                               ) { 
+        m_var_name   = var_name;
+        m_client_min = client_min_value;
+        m_client_max = client_max_value;
+
+        m_port_min   = port_min;
+        m_port_max   = port_max;
+
+        m_limit_num_flows = limit_num_flows;
+        m_flags = flags;
+    }
+
+    virtual void Dump(FILE *fd);
+
+    static uint8_t get_flow_var_size(){
+        return  (4+2+4);
+    }
+
+    bool is_unlimited_flows(){
+        return ( (m_flags &   StreamVmInstructionFlowClient::CLIENT_F_UNLIMITED_FLOWS ) == 
+                  StreamVmInstructionFlowClient::CLIENT_F_UNLIMITED_FLOWS );
+    }
+public:
+
+
+    /* flow var name */
+    std::string   m_var_name;
+
+    uint32_t m_client_min;  // min ip 
+    uint32_t m_client_max;  // max ip 
+    uint16_t m_port_min;  // start port 
+    uint16_t m_port_max;  // start port 
+    uint32_t m_limit_num_flows;   // number of flows
+    uint16_t m_flags;
+};
+
+
+
+class VmFlowVarRec {
+public:
+    uint32_t    m_offset;
+    union {
+        StreamVmInstructionFlowMan * m_ins_flowv;
+        StreamVmInstructionFlowClient * m_ins_flow_client;
+    } m_ins;
+    uint8_t    m_size_bytes;
+};
+
+
+
+
 /**
  * write flow var to packet
  * 
@@ -121,7 +753,14 @@ public:
                                                         m_pkt_offset(pkt_offset),
                                                         m_add_value(add_value),
                                                         m_is_big_endian(is_big_endian) {}
-private:
+
+    virtual instruction_type_t get_instruction_type(){
+        return ( StreamVmInstruction::itPKT_WR);
+    }
+
+    virtual void Dump(FILE *fd);
+
+public:
 
     /* flow var name to write */
     std::string   m_flow_var_name;
@@ -136,12 +775,161 @@ private:
     bool         m_is_big_endian;
 };
 
+
+/**
+ * describes a VM program for DP 
+ * 
+ */
+
+class StreamVmDp {
+public:
+    StreamVmDp(){
+        m_bss_ptr=NULL; 
+        m_program_ptr =NULL ;
+        m_bss_size=0;
+        m_program_size=0;
+        m_max_pkt_offset_change=0;
+    }
+
+    StreamVmDp( uint8_t * bss,
+                uint16_t bss_size,
+                uint8_t * prog,
+                uint16_t prog_size,
+                uint16_t max_pkt_offset
+                ){
+
+        if (bss) {
+            assert(bss_size);
+            m_bss_ptr=(uint8_t*)malloc(bss_size);
+            assert(m_bss_ptr);
+            memcpy(m_bss_ptr,bss,bss_size);
+            m_bss_size=bss_size;
+        }else{
+            m_bss_ptr=NULL; 
+            m_bss_size=0;
+        }
+
+        if (prog) {
+            assert(prog_size);
+            m_program_ptr=(uint8_t*)malloc(prog_size);
+            memcpy(m_program_ptr,prog,prog_size);
+            m_program_size = prog_size;
+        }else{
+            m_program_ptr = NULL;
+            m_program_size=0;
+        }
+        m_max_pkt_offset_change =max_pkt_offset;
+    }
+
+    ~StreamVmDp(){
+        if (m_bss_ptr) {
+            free(m_bss_ptr);
+            m_bss_ptr=0;
+            m_bss_size=0;
+        }
+        if (m_program_ptr) {
+            free(m_program_ptr);
+            m_program_size=0;
+            m_program_ptr=0;
+        }
+    }
+
+    StreamVmDp * clone() const {
+        StreamVmDp * lp= new StreamVmDp(m_bss_ptr,
+                                        m_bss_size,
+                                        m_program_ptr,
+                                        m_program_size,
+                                        m_max_pkt_offset_change
+                                        );
+        assert(lp);
+        return (lp);
+    }
+
+    uint8_t* clone_bss(){
+        assert(m_bss_size>0);
+        uint8_t *p=(uint8_t *)malloc(m_bss_size);
+        assert(p);
+        memcpy(p,m_bss_ptr,m_bss_size);
+        return (p);
+    }
+
+    uint16_t get_bss_size(){
+        return(m_bss_size);
+    }
+
+    uint8_t*  get_bss(){
+        return (m_bss_ptr);
+    }
+
+    uint8_t*  get_program(){
+        return (m_program_ptr);
+    }
+
+    uint16_t  get_program_size(){
+        return (m_program_size);
+    }
+
+    uint16_t get_max_packet_update_offset(){
+        return (m_max_pkt_offset_change);
+    }
+
+private:
+    uint8_t *  m_bss_ptr; /* pointer to the data section */
+    uint8_t *  m_program_ptr; /* pointer to the program */
+    uint16_t   m_bss_size;
+    uint16_t   m_program_size; /* program size*/
+    uint16_t   m_max_pkt_offset_change;
+
+};
+
+
 /**
  * describes a VM program
  * 
  */
 class StreamVm {
+
 public:
+    enum STREAM_VM {
+        svMAX_FLOW_VAR   = 64, /* maximum flow varible */
+        svMAX_PACKET_OFFSET_CHANGE = 512
+    };
+
+
+
+    StreamVm(){
+        m_bss=0;
+        m_pkt_size=0;
+        m_cur_var_offset=0;
+    }
+
+
+    /* set packet size */
+    void set_packet_size(uint16_t pkt_size){
+        m_pkt_size = pkt_size;
+    }
+
+    uint16_t get_packet_size(){
+        return ( m_pkt_size);
+    }
+
+
+    StreamVmDp * cloneAsVmDp(){
+
+        StreamVmDp * lp= new StreamVmDp(get_bss_ptr(),
+                                        get_bss_size(),
+                                        get_dp_instruction_buffer()->get_program(),
+                                        get_dp_instruction_buffer()->get_program_size(),
+                                        get_max_packet_update_offset()
+                                        );
+        assert(lp);
+        return (lp);
+        
+    }
+
+    bool is_vm_empty() {
+        return (m_inst_list.size() == 0);
+    }
 
     /**
      * add new instruction to the VM
@@ -155,17 +943,75 @@ public:
      */
     const std::vector<StreamVmInstruction *> & get_instruction_list();
 
+    StreamDPVmInstructions  *           get_dp_instruction_buffer();
+
+    uint16_t                                  get_bss_size(){
+        return (m_cur_var_offset );
+    }
+
+    uint8_t *                                 get_bss_ptr(){
+        return (m_bss );
+    }
+
+
+    uint16_t                                  get_max_packet_update_offset(){
+        return ( m_max_field_update );
+    }
+
+
+
     /**
      * compile the VM 
      * return true of success, o.w false 
      * 
      */
-    bool compile();
+    void compile();
 
     ~StreamVm();
 
+    void Dump(FILE *fd);
+
+    /* raise exception */
+    void  err(const std::string &err);
+
 private:
+
+    /* lookup for varible offset, */
+    bool var_lookup(const std::string &var_name,VmFlowVarRec & var);
+
+    void  var_clear_table();
+
+    bool  var_add(const std::string &var_name,VmFlowVarRec & var);
+
+    uint16_t get_var_offset(const std::string &var_name);
+    
+    void build_flow_var_table() ;
+
+    void build_bss();
+
+    void build_program();
+
+    void alloc_bss();
+
+    void free_bss();
+
+private:
+
+    void clean_max_field_cnt();
+
+    void add_field_cnt(uint16_t new_cnt);
+
+private:
+    uint16_t                           m_pkt_size;
+    uint16_t                           m_cur_var_offset;
+    uint16_t                           m_max_field_update; /* the location of the last byte that is going to be changed in the packet */ 
+
     std::vector<StreamVmInstruction *> m_inst_list;
+    std::unordered_map<std::string, VmFlowVarRec> m_flow_var_offset;
+    uint8_t *                          m_bss;
+
+    StreamDPVmInstructions             m_instructions;
+    
 };
 
 #endif /* __TREX_STREAM_VM_API_H__ */
diff --git a/src/stateless/cp/trex_streams_compiler.cpp b/src/stateless/cp/trex_streams_compiler.cpp
index b28989be..c4900e66 100644
--- a/src/stateless/cp/trex_streams_compiler.cpp
+++ b/src/stateless/cp/trex_streams_compiler.cpp
@@ -142,8 +142,9 @@ private:
 /**************************************
  * stream compiled object
  *************************************/
-TrexStreamsCompiledObj::TrexStreamsCompiledObj(uint8_t port_id, double mul) : m_port_id(port_id), m_mul(mul) {
-      m_all_continues=false;
+TrexStreamsCompiledObj::TrexStreamsCompiledObj(uint8_t port_id) {
+    m_port_id = port_id;
+    m_all_continues = false;
 }
 
 TrexStreamsCompiledObj::~TrexStreamsCompiledObj() {
@@ -155,53 +156,40 @@ TrexStreamsCompiledObj::~TrexStreamsCompiledObj() {
 
 
 void 
-TrexStreamsCompiledObj::add_compiled_stream(TrexStream * stream){
+TrexStreamsCompiledObj::add_compiled_stream(TrexStream *stream){
 
     obj_st obj;
 
-    obj.m_stream = stream->clone_as_dp();
+    obj.m_stream = stream;
 
     m_objs.push_back(obj);
 }
 
-void 
-TrexStreamsCompiledObj::add_compiled_stream(TrexStream * stream,
-                                            uint32_t my_dp_id, int next_dp_id) {
-    obj_st obj;
-
-    obj.m_stream = stream->clone_as_dp();
-    /* compress the id's*/
-    obj.m_stream->fix_dp_stream_id(my_dp_id,next_dp_id);
-
-    m_objs.push_back(obj);
-}
-
-void TrexStreamsCompiledObj::Dump(FILE *fd){
-    for (auto obj : m_objs) {
-        obj.m_stream->Dump(fd);
-    }
-}
-
-
 
 TrexStreamsCompiledObj *
 TrexStreamsCompiledObj::clone() {
 
-    /* use multiplier of 1 to avoid double mult */
-    TrexStreamsCompiledObj *new_compiled_obj = new TrexStreamsCompiledObj(m_port_id, 1);
+    TrexStreamsCompiledObj *new_compiled_obj = new TrexStreamsCompiledObj(m_port_id);
 
     /**
      * clone each element
      */
     for (auto obj : m_objs) {
-        new_compiled_obj->add_compiled_stream(obj.m_stream);
+        TrexStream *new_stream = obj.m_stream->clone_as_dp();
+        new_compiled_obj->add_compiled_stream(new_stream);
     }
 
-    new_compiled_obj->m_mul = m_mul;
-
     return new_compiled_obj;
+
 }
 
+void TrexStreamsCompiledObj::Dump(FILE *fd){
+    for (auto obj : m_objs) {
+        obj.m_stream->Dump(fd);
+    }
+}
+
+
 void
 TrexStreamsCompiler::add_warning(const std::string &warning) {
     m_warnings.push_back("*** warning: " + warning);
@@ -219,7 +207,7 @@ TrexStreamsCompiler::check_stream(const TrexStream *stream) {
     /* cont. stream can point only on itself */
     if (stream->get_type() == TrexStream::stCONTINUOUS) {
         if (stream->m_next_stream_id != -1) {
-            ss << "continous stream '" << stream->m_stream_id << "' cannot point on another stream";
+            ss << "continous stream '" << stream->m_stream_id << "' cannot point to another stream";
             err(ss.str());
         }
     }
@@ -381,12 +369,34 @@ TrexStreamsCompiler::pre_compile_check(const std::vector<TrexStream *> &streams,
  * stream compiler
  *************************************/
 bool 
-TrexStreamsCompiler::compile(const std::vector<TrexStream *> &streams,
-                             TrexStreamsCompiledObj &obj,
-                             std::string *fail_msg) {
+TrexStreamsCompiler::compile(uint8_t                                port_id,
+                             const std::vector<TrexStream *>        &streams,
+                             std::vector<TrexStreamsCompiledObj *>  &objs,
+                             uint8_t                                dp_core_count,
+                             double                                 factor,
+                             std::string                            *fail_msg) {
+
+    try {
+        return compile_internal(port_id,streams,objs,dp_core_count,factor,fail_msg);
+    } catch (const TrexException &ex) {
+        if (fail_msg) {
+            *fail_msg = ex.what();
+        } else {
+            std::cout << ex.what();
+        }
+        return false;
+    }
+
+}
+bool 
+TrexStreamsCompiler::compile_internal(uint8_t                                port_id,
+                                      const std::vector<TrexStream *>        &streams,
+                                      std::vector<TrexStreamsCompiledObj *>  &objs,
+                                      uint8_t                                dp_core_count,
+                                      double                                 factor,
+                                      std::string                            *fail_msg) {
 
 #if 0
-    fprintf(stdout,"------------pre compile \n");
     for (auto stream : streams) {
         stream->Dump(stdout);
     }
@@ -397,49 +407,100 @@ TrexStreamsCompiler::compile(const std::vector<TrexStream *> &streams,
 
 
     /* compile checks */
-    try {
-        pre_compile_check(streams,nodes);
-    } catch (const TrexException &ex) {
-        if (fail_msg) {
-            *fail_msg = ex.what();
-        } else {
-            std::cout << ex.what();
+    pre_compile_check(streams, nodes);
+
+    /* check if all are cont. streams */
+    bool all_continues = true;
+    for (const auto stream : streams) {
+        if (stream->get_type() != TrexStream::stCONTINUOUS) {
+            all_continues = false;
+            break;
         }
-        return false;
     }
 
+    /* allocate objects for all DP cores */
+    for (uint8_t i = 0; i < dp_core_count; i++) {
+        TrexStreamsCompiledObj *obj = new TrexStreamsCompiledObj(port_id);
+        obj->m_all_continues = all_continues;
+        objs.push_back(obj);
+    }
 
-    bool all_continues=true;
-    /* for now we do something trivial, */
+    /* compile all the streams */
     for (auto stream : streams) {
 
         /* skip non-enabled streams */
         if (!stream->m_enabled) {
             continue;
         }
-        if (stream->get_type() != TrexStream::stCONTINUOUS ) {
-            all_continues=false;
-        }
+     
+        /* compile a single stream to all cores */
+        compile_stream(stream, factor, dp_core_count, objs, nodes);
+    }
 
-        int new_id= nodes.get(stream->m_stream_id)->m_compressed_stream_id;
-        assert(new_id>=0);
-        uint32_t my_stream_id = (uint32_t)new_id;
-        int my_next_stream_id=-1;
-        if (stream->m_next_stream_id>=0) {
-            my_next_stream_id=nodes.get(stream->m_next_stream_id)->m_compressed_stream_id;
-        }
+    return true;
+}
 
-        /* add it */
-        obj.add_compiled_stream(stream,
-                                my_stream_id,
-                                my_next_stream_id
-                                );
-        
+/**
+ * compiles a single stream to DP objects
+ * 
+ * @author imarom (03-Dec-15)
+ * 
+ */
+void
+TrexStreamsCompiler::compile_stream(const TrexStream *stream,
+                                    double factor,
+                                    uint8_t dp_core_count,
+                                    std::vector<TrexStreamsCompiledObj *> &objs,
+                                    GraphNodeMap &nodes) {
+
+
+    /* fix the stream ids */
+    int new_id = nodes.get(stream->m_stream_id)->m_compressed_stream_id;
+    assert(new_id >= 0);
+
+    int new_next_id = -1;
+    if (stream->m_next_stream_id >= 0) {
+        new_next_id = nodes.get(stream->m_next_stream_id)->m_compressed_stream_id;
     }
-    obj.m_all_continues =all_continues;
-    return true;
+
+    /* calculate rate */
+    double per_core_rate          = (stream->m_pps * (factor / dp_core_count));
+    int per_core_burst_total_pkts = (stream->m_burst_total_pkts / dp_core_count);
+
+    /* compile VM */
+    /* fix this const away problem */
+    ((TrexStream *)stream)->compile();
+
+    std::vector<TrexStream *> per_core_streams(dp_core_count);
+
+    /* for each core - creates its own version of the stream */
+    for (uint8_t i = 0; i < dp_core_count; i++) {
+        TrexStream *dp_stream = stream->clone_as_dp();
+
+        /* fix stream ID */
+        dp_stream->fix_dp_stream_id(new_id, new_next_id);
+
+
+        /* adjust rate and packets count */
+        dp_stream->m_pps               = per_core_rate;
+        dp_stream->m_burst_total_pkts  = per_core_burst_total_pkts;
+
+        per_core_streams[i] = dp_stream;
+    }
+
+    /* take care of remainder from a burst */
+    int burst_remainder = stream->m_burst_total_pkts - (per_core_burst_total_pkts * dp_core_count);
+    per_core_streams[0]->m_burst_total_pkts += burst_remainder;
+
+    /* attach the compiled stream of every core to its object */
+    for (uint8_t i = 0; i < dp_core_count; i++) {
+        objs[i]->add_compiled_stream(per_core_streams[i]);
+    }
+
+
 }
 
+
 /**************************************
  * streams graph
  *************************************/
@@ -486,10 +547,13 @@ TrexStreamsGraph::add_rate_events_for_stream_cont(double &offset_usec, const Tre
     start_event.time = offset_usec + stream->m_isg_usec;
     start_event.diff_pps = stream->get_pps();
     start_event.diff_bps = stream->get_bps();
-    m_graph_obj.add_rate_event(start_event);
+    m_graph_obj->add_rate_event(start_event);
 
     /* no more events after this stream */
     offset_usec = -1;
+
+    /* also mark we have an inifite time */
+    m_graph_obj->m_expected_duration = -1;
 }
 
 /**
@@ -510,13 +574,13 @@ TrexStreamsGraph::add_rate_events_for_stream_single_burst(double &offset_usec, c
     start_event.time = offset_usec + stream->m_isg_usec;
     start_event.diff_pps = stream->get_pps();
     start_event.diff_bps = stream->get_bps();
-    m_graph_obj.add_rate_event(start_event);
+    m_graph_obj->add_rate_event(start_event);
 
     /* stop event */
     stop_event.time = start_event.time + stream->get_burst_length_usec();
     stop_event.diff_pps = -(start_event.diff_pps);
     stop_event.diff_bps = -(start_event.diff_bps);
-    m_graph_obj.add_rate_event(stop_event);
+    m_graph_obj->add_rate_event(stop_event);
 
     /* next stream starts from here */
     offset_usec = stop_event.time;
@@ -549,10 +613,10 @@ TrexStreamsGraph::add_rate_events_for_stream_multi_burst(double &offset_usec, co
     for (int i = 0; i < stream->m_num_bursts; i++) {
 
         start_event.time = offset_usec + delay;
-        m_graph_obj.add_rate_event(start_event);
+        m_graph_obj->add_rate_event(start_event);
 
         stop_event.time = start_event.time + stream->get_burst_length_usec();
-        m_graph_obj.add_rate_event(stop_event);
+        m_graph_obj->add_rate_event(stop_event);
 
         /* after the first burst, the delay is inter burst gap */
         delay = stream->m_ibg_usec;
@@ -602,6 +666,7 @@ TrexStreamsGraph::generate_graph_for_one_root(uint32_t root_stream_id) {
         /* loop detection */
         auto search = loop_hash.find(stream->m_next_stream_id);
         if (search != loop_hash.end()) {
+            m_graph_obj->on_loop_detection();
             break;
         }
 
@@ -615,8 +680,12 @@ TrexStreamsGraph::generate_graph_for_one_root(uint32_t root_stream_id) {
  * see graph object for more details 
  * 
  */
-const TrexStreamsGraphObj &
+const TrexStreamsGraphObj *
 TrexStreamsGraph::generate(const std::vector<TrexStream *> &streams) {
+
+    /* main object to hold the graph - returned to the user */
+    m_graph_obj = new TrexStreamsGraphObj();
+
     std::vector <uint32_t> root_streams;
 
     /* before anything we create a hash streams ID
@@ -644,7 +713,7 @@ TrexStreamsGraph::generate(const std::vector<TrexStream *> &streams) {
     }
 
 
-    m_graph_obj.generate();
+    m_graph_obj->generate();
 
     return m_graph_obj;
 }
@@ -670,6 +739,11 @@ TrexStreamsGraphObj::find_max_rate() {
         max_rate_bps = std::max(max_rate_bps, current_rate_bps);
     }
 
+    /* if not mark as inifite - get the last event time */
+    if (m_expected_duration != -1) {
+        m_expected_duration = m_rate_events.back().time;
+    }
+
     m_max_pps = max_rate_pps;
     m_max_bps = max_rate_bps;
 }
diff --git a/src/stateless/cp/trex_streams_compiler.h b/src/stateless/cp/trex_streams_compiler.h
index 70a31c5e..d2b0cd1d 100644
--- a/src/stateless/cp/trex_streams_compiler.h
+++ b/src/stateless/cp/trex_streams_compiler.h
@@ -38,9 +38,10 @@ class GraphNodeMap;
  */
 class TrexStreamsCompiledObj {
     friend class TrexStreamsCompiler;
+
 public:
 
-    TrexStreamsCompiledObj(uint8_t port_id, double m_mul);
+    TrexStreamsCompiledObj(uint8_t port_id);
     ~TrexStreamsCompiledObj();
 
     struct obj_st {
@@ -56,32 +57,22 @@ public:
         return (m_port_id);
     }
 
-    /**
-     * clone the compiled object
-     * 
-     */
-    TrexStreamsCompiledObj * clone();
-
-    double get_multiplier(){
-        return (m_mul);
-    }
-
     bool get_all_streams_continues(){
         return (m_all_continues);
     }
 
     void Dump(FILE *fd);
 
+    TrexStreamsCompiledObj* clone();
+
 private:
-    void add_compiled_stream(TrexStream * stream,
-                             uint32_t my_dp_id, int next_dp_id);
-    void add_compiled_stream(TrexStream * stream);
+    void add_compiled_stream(TrexStream *stream);
+
 
     std::vector<obj_st> m_objs;
 
     bool    m_all_continues;
     uint8_t m_port_id;
-    double  m_mul;
 };
 
 class TrexStreamsCompiler {
@@ -93,7 +84,13 @@ public:
      * @author imarom (28-Oct-15)
      * 
      */
-    bool compile(const std::vector<TrexStream *> &streams, TrexStreamsCompiledObj &obj, std::string *fail_msg = NULL);
+    bool compile(uint8_t                                port_id,
+                 const std::vector<TrexStream *>        &streams,
+                 std::vector<TrexStreamsCompiledObj *>  &objs,
+                 uint8_t                                dp_core_count = 1,
+                 double                                 factor = 1.0,
+                 std::string                            *fail_msg = NULL);
+
 
     /**
      * 
@@ -106,6 +103,13 @@ public:
 
 private:
 
+    bool compile_internal(uint8_t                                port_id,
+                          const std::vector<TrexStream *>        &streams,
+                          std::vector<TrexStreamsCompiledObj *>  &objs,
+                          uint8_t                                dp_core_count,
+                          double                                 factor,
+                          std::string                            *fail_msg);
+
     void pre_compile_check(const std::vector<TrexStream *> &streams,
                            GraphNodeMap & nodes);
     void allocate_pass(const std::vector<TrexStream *> &streams, GraphNodeMap *nodes);
@@ -115,8 +119,15 @@ private:
     void add_warning(const std::string &warning);
     void err(const std::string &err);
 
+    void compile_stream(const TrexStream *stream,
+                        double factor,
+                        uint8_t dp_core_count,
+                        std::vector<TrexStreamsCompiledObj *> &objs,
+                        GraphNodeMap &nodes);
+
+    void compile_stream_vm(TrexStream *stream);
+
     std::vector<std::string> m_warnings;
-    
 };
 
 class TrexStreamsGraph;
@@ -131,6 +142,12 @@ class TrexStreamsGraphObj {
 
 public:
 
+    TrexStreamsGraphObj() {
+        m_max_pps           = 0;
+        m_max_bps           = 0;
+        m_expected_duration = 0;
+    }
+
     /**
      * rate event is defined by those: 
      * time - the time of the event on the timeline 
@@ -153,12 +170,21 @@ public:
         return m_max_bps;
     }
 
+    int get_duration() const {
+        return m_expected_duration;
+    }
+
     const std::list<rate_event_st> & get_events() const {
         return m_rate_events;
     }
 
+
 private:
 
+    void on_loop_detection() {
+        m_expected_duration = -1;
+    }
+
     void add_rate_event(const rate_event_st &ev) {
         m_rate_events.push_back(ev);
     }
@@ -166,11 +192,13 @@ private:
     void generate();
     void find_max_rate();
 
-    double m_max_pps;
-    double m_max_bps;
+    double  m_max_pps;
+    double  m_max_bps;
+    int     m_expected_duration;
 
     /* list of rate events */
     std::list<rate_event_st> m_rate_events;
+
 };
 
 /**
@@ -181,11 +209,15 @@ private:
 class TrexStreamsGraph {
 public:
 
+    TrexStreamsGraph() {
+        m_graph_obj = NULL;
+    }
+
     /**
      * generate a sequence graph for streams
      * 
      */
-    const TrexStreamsGraphObj & generate(const std::vector<TrexStream *> &streams);
+    const TrexStreamsGraphObj * generate(const std::vector<TrexStream *> &streams);
 
 private:
 
@@ -200,7 +232,7 @@ private:
     std::unordered_map<uint32_t, const TrexStream *> m_streams_hash;
 
     /* main object to hold the graph - returned to the user */
-    TrexStreamsGraphObj m_graph_obj;
+    TrexStreamsGraphObj *m_graph_obj;
 };
 
 #endif /* __TREX_STREAMS_COMPILER_H__ */
diff --git a/src/stateless/dp/trex_stateless_dp_core.cpp b/src/stateless/dp/trex_stateless_dp_core.cpp
index dd4937cd..585ff2c7 100644
--- a/src/stateless/dp/trex_stateless_dp_core.cpp
+++ b/src/stateless/dp/trex_stateless_dp_core.cpp
@@ -106,12 +106,56 @@ std::string CGenNodeStateless::get_stream_state_str(stream_state_t stream_state)
 }
 
 
+rte_mbuf_t   * CGenNodeStateless::alloc_node_with_vm(){
+
+    rte_mbuf_t        * m;
+    /* alloc small packet buffer*/
+    uint16_t prefix_size = prefix_header_size();
+    m = CGlobalInfo::pktmbuf_alloc( get_socket_id(), prefix_size );
+    if (m==0) {
+        return (m);
+    }
+    /* TBD remove this, should handle cases of error */
+    assert(m);
+    char *p=rte_pktmbuf_append(m, prefix_size);
+    memcpy( p ,m_original_packet_data_prefix, prefix_size); 
+
+
+    /* run the VM program */
+    StreamDPVmInstructionsRunner runner;
+
+    runner.run( m_vm_program_size, 
+                m_vm_program,
+                m_vm_flow_var,
+                (uint8_t*)p);
+
+
+    rte_mbuf_t * m_const = get_const_mbuf();
+    if (  m_const != NULL) {
+        utl_rte_pktmbuf_add_after(m,m_const);
+    }
+    return (m);
+}
+
+
 void CGenNodeStateless::free_stl_node(){
     /* if we have cache mbuf free it */
     rte_mbuf_t * m=get_cache_mbuf();
     if (m) {
         rte_pktmbuf_free(m);
         m_cache_mbuf=0;
+    }else{
+        /* non cache - must have an header */
+         m=get_const_mbuf();
+         if (m) {
+             rte_pktmbuf_free(m); /* reduce the ref counter */
+         }
+         free_prefix_header();
+    }
+    if (m_vm_flow_var) {
+        /* free flow var */
+        free(m_vm_flow_var);
+        m_vm_flow_var=0;
     }
 }
 
@@ -139,7 +183,7 @@ bool TrexStatelessDpPerPort::resume_traffic(uint8_t port_id){
     return (true);
 }
 
-bool TrexStatelessDpPerPort::update_traffic(uint8_t port_id, double mul) {
+bool TrexStatelessDpPerPort::update_traffic(uint8_t port_id, double factor) {
 
     assert( (m_state == TrexStatelessDpPerPort::ppSTATE_TRANSMITTING || 
             (m_state == TrexStatelessDpPerPort::ppSTATE_PAUSE)) );
@@ -148,7 +192,7 @@ bool TrexStatelessDpPerPort::update_traffic(uint8_t port_id, double mul) {
         CGenNodeStateless * node = dp_stream.m_node; 
         assert(node->get_port_id() == port_id);
 
-        node->set_multiplier(mul);
+        node->update_rate(factor);
     }
 
     return (true);
@@ -423,6 +467,7 @@ TrexStatelessDpCore::add_stream(TrexStatelessDpPerPort * lp_port,
     CGenNodeStateless *node = m_core->create_node_sl();
 
     /* add periodic */
+    node->m_cache_mbuf=0;
     node->m_type = CGenNode::STATELESS_PKT;
 
     node->m_ref_stream_info  =   stream->clone_as_dp();
@@ -442,6 +487,10 @@ TrexStatelessDpCore::add_stream(TrexStatelessDpPerPort * lp_port,
 
     pkt_dir_t dir = m_core->m_node_gen.m_v_if->port_id_to_dir(stream->m_port_id);
     node->m_flags = 0; 
+    node->m_src_port =0;
+    node->m_original_packet_data_prefix = 0;
+
+
 
     /* set socket id */
     node->set_socket_id(m_core->m_node_gen.m_socket_id);
@@ -453,8 +502,7 @@ TrexStatelessDpCore::add_stream(TrexStatelessDpPerPort * lp_port,
 
     node->m_pause =0;
     node->m_stream_type = stream->m_type;
-    node->m_base_pps = stream->get_pps();
-    node->set_multiplier(comp->get_multiplier());
+    node->m_next_time_offset = 1.0 / stream->get_pps();
 
     /* stateless specific fields */
     switch ( stream->m_type ) {
@@ -487,23 +535,77 @@ TrexStatelessDpCore::add_stream(TrexStatelessDpPerPort * lp_port,
 
     node->m_port_id = stream->m_port_id;
 
-    /* allocate const mbuf */
-    rte_mbuf_t *m = CGlobalInfo::pktmbuf_alloc(node->get_socket_id(), pkt_size);
-    assert(m);
-
-    char *p = rte_pktmbuf_append(m, pkt_size);
-    assert(p);
-    /* copy the packet */
-    memcpy(p,stream_pkt,pkt_size);
-
     /* set dir 0 or 1 client or server */
     node->set_mbuf_cache_dir(dir);
 
-    /* TBD repace the mac if req we should add flag  */
-    m_core->m_node_gen.m_v_if->update_mac_addr_from_global_cfg(dir, m);
 
-    /* set the packet as a readonly */
-    node->set_cache_mbuf(m);
+    if (stream->is_vm()  == false ) {
+        /* no VM */
+
+        node->m_vm_flow_var =  NULL;
+        node->m_vm_program  =  NULL;
+        node->m_vm_program_size =0;
+
+                /* allocate const mbuf */
+        rte_mbuf_t *m = CGlobalInfo::pktmbuf_alloc(node->get_socket_id(), pkt_size);
+        assert(m);
+    
+        char *p = rte_pktmbuf_append(m, pkt_size);
+        assert(p);
+        /* copy the packet */
+        memcpy(p,stream_pkt,pkt_size);
+    
+        /* TBD repace the mac if req we should add flag  */
+        m_core->m_node_gen.m_v_if->update_mac_addr_from_global_cfg(dir,(uint8_t*) p);
+    
+        /* set the packet as a readonly */
+        node->set_cache_mbuf(m);
+
+        node->m_original_packet_data_prefix =0;
+    }else{
+
+        /* set the program */
+        TrexStream * local_mem_stream = node->m_ref_stream_info;
+
+        StreamVmDp  * lpDpVm = local_mem_stream->getDpVm();
+
+        node->m_vm_flow_var =  lpDpVm->clone_bss(); /* clone the flow var */
+        node->m_vm_program  =  lpDpVm->get_program(); /* same ref to the program */
+        node->m_vm_program_size =lpDpVm->get_program_size();
+
+
+        /* we need to copy the object */
+        if ( pkt_size > stream->m_vm_prefix_size  ) {
+            /* we need const packet */
+            uint16_t const_pkt_size  = pkt_size - stream->m_vm_prefix_size ;
+            rte_mbuf_t *m = CGlobalInfo::pktmbuf_alloc(node->get_socket_id(), const_pkt_size );
+            assert(m);
+
+            char *p = rte_pktmbuf_append(m, const_pkt_size);
+            assert(p);
+
+            /* copy packet data */
+            memcpy(p,(stream_pkt+ stream->m_vm_prefix_size),const_pkt_size);
+
+            node->set_const_mbuf(m);
+        }
+
+
+        if (stream->m_vm_prefix_size > pkt_size ) {
+            stream->m_vm_prefix_size = pkt_size;
+        }
+        /* copy the headr */
+        uint16_t header_size = stream->m_vm_prefix_size;
+        assert(header_size);
+        node->alloc_prefix_header(header_size);
+        uint8_t *p=node->m_original_packet_data_prefix;
+        assert(p);
+
+        memcpy(p,stream_pkt , header_size);
+        /* TBD repace the mac if req we should add flag  */
+        m_core->m_node_gen.m_v_if->update_mac_addr_from_global_cfg(dir, p);
+    }
+
 
     CDpOneStream one_stream;
 
@@ -597,11 +699,11 @@ TrexStatelessDpCore::pause_traffic(uint8_t port_id){
 }
 
 void 
-TrexStatelessDpCore::update_traffic(uint8_t port_id, double mul) {
+TrexStatelessDpCore::update_traffic(uint8_t port_id, double factor) {
 
     TrexStatelessDpPerPort * lp_port = get_port_db(port_id);
 
-    lp_port->update_traffic(port_id, mul);
+    lp_port->update_traffic(port_id, factor);
 }
 
 
diff --git a/src/stateless/dp/trex_stateless_dp_core.h b/src/stateless/dp/trex_stateless_dp_core.h
index 563159b2..7dc4a2b2 100644
--- a/src/stateless/dp/trex_stateless_dp_core.h
+++ b/src/stateless/dp/trex_stateless_dp_core.h
@@ -68,7 +68,7 @@ public:
 
     bool resume_traffic(uint8_t port_id);
 
-    bool update_traffic(uint8_t port_id, double mul);
+    bool update_traffic(uint8_t port_id, double factor);
 
     bool stop_traffic(uint8_t port_id,
                       bool stop_on_id, 
diff --git a/src/stateless/dp/trex_stream_node.h b/src/stateless/dp/trex_stream_node.h
index 5997376f..d33785fe 100644
--- a/src/stateless/dp/trex_stream_node.h
+++ b/src/stateless/dp/trex_stream_node.h
@@ -54,6 +54,16 @@ struct CGenNodeStateless : public CGenNodeBase  {
 friend class TrexStatelessDpCore;
 
 public:
+
+    /* flags MASKS*/
+    enum {
+        SL_NODE_FLAGS_DIR                  =1, //USED by master
+        SL_NODE_FLAGS_MBUF_CACHE           =2, //USED by master
+
+        SL_NODE_CONST_MBUF                =4
+
+    };
+
     enum {                                          
             ss_FREE_RESUSE =1, /* should be free by scheduler */
             ss_INACTIVE    =2, /* will be active by other stream or stopped */
@@ -83,14 +93,20 @@ private:
     uint32_t            m_multi_bursts; /* in case of multi_burst how many bursts */
 
     /* cache line 1 */
-    TrexStream *        m_ref_stream_info; /* the stream info */
+    TrexStream *         m_ref_stream_info; /* the stream info */
     CGenNodeStateless  * m_next_stream;
 
-    double              m_base_pps;
-    /* pad to match the size of CGenNode */
-    uint8_t             m_pad_end[48];
+    uint8_t *            m_original_packet_data_prefix; /* pointer to the original first pointer 64/128/512 */
+
+    /* Fast Field VM section */
+    uint8_t *            m_vm_flow_var; /* pointer to the vm flow var */
+    uint8_t *            m_vm_program;  /* pointer to the program */
+    uint16_t             m_vm_program_size; /* up to 64K op codes */
 
+    /* End Fast Field VM Section */
 
+    /* pad to match the size of CGenNode */
+    uint8_t             m_pad_end[30];
 
 
 public:
@@ -105,8 +121,9 @@ public:
      * on the PPS and multiplier 
      * 
      */
-    void set_multiplier(double mul) {
-        m_next_time_offset =  1.0 / (m_base_pps * mul) ;
+    void update_rate(double factor) {
+        /* update the inter packet gap */
+        m_next_time_offset         =  m_next_time_offset / factor;
     }
 
     /* we restart the stream, schedule it using stream isg */
@@ -256,13 +273,51 @@ public:
     }
 
     inline rte_mbuf_t * get_cache_mbuf(){
-        if ( m_flags &NODE_FLAGS_MBUF_CACHE ) {
+        if ( m_flags & NODE_FLAGS_MBUF_CACHE ) {
+            return ((rte_mbuf_t *)m_cache_mbuf);
+        }else{
+            return ((rte_mbuf_t *)0);
+        }
+    }
+
+    inline void set_const_mbuf(rte_mbuf_t * m){
+        m_cache_mbuf=(void *)m;
+        m_flags |= SL_NODE_CONST_MBUF;
+    }
+
+    inline rte_mbuf_t * get_const_mbuf(){
+        if ( m_flags &SL_NODE_CONST_MBUF ) {
             return ((rte_mbuf_t *)m_cache_mbuf);
         }else{
             return ((rte_mbuf_t *)0);
         }
     }
 
+    /* prefix header exits only in non cache mode size is 64/128/512  other are not possible right now */
+    inline void alloc_prefix_header(uint16_t size){
+         set_prefix_header_size(size);
+         m_original_packet_data_prefix = (uint8_t *)malloc(size);
+         assert(m_original_packet_data_prefix);
+    }
+
+    inline void free_prefix_header(){
+         if (m_original_packet_data_prefix) {
+             free(m_original_packet_data_prefix);
+         }
+    }
+
+    /* prefix headr could be 64/128/512 */
+    inline void set_prefix_header_size(uint16_t size){
+        m_src_port=size;
+    }
+
+    inline uint16_t prefix_header_size(){
+        return (m_src_port);
+    }
+
+
+    rte_mbuf_t   * alloc_node_with_vm();
+
     void free_stl_node();
 
 public:
diff --git a/src/stateless/messaging/trex_stateless_messaging.cpp b/src/stateless/messaging/trex_stateless_messaging.cpp
index 3210f29a..257de168 100644
--- a/src/stateless/messaging/trex_stateless_messaging.cpp
+++ b/src/stateless/messaging/trex_stateless_messaging.cpp
@@ -168,14 +168,14 @@ TrexStatelessDpCanQuit::clone(){
  ************************/ 
 bool
 TrexStatelessDpUpdate::handle(TrexStatelessDpCore *dp_core) {
-    dp_core->update_traffic(m_port_id, m_mul);
+    dp_core->update_traffic(m_port_id, m_factor);
 
     return true;
 }
 
 TrexStatelessCpToDpMsgBase *
 TrexStatelessDpUpdate::clone() {
-    TrexStatelessCpToDpMsgBase *new_msg = new TrexStatelessDpUpdate(m_port_id, m_mul);
+    TrexStatelessCpToDpMsgBase *new_msg = new TrexStatelessDpUpdate(m_port_id, m_factor);
 
     return new_msg;
 }
diff --git a/src/stateless/messaging/trex_stateless_messaging.h b/src/stateless/messaging/trex_stateless_messaging.h
index 7390be60..d56596bf 100644
--- a/src/stateless/messaging/trex_stateless_messaging.h
+++ b/src/stateless/messaging/trex_stateless_messaging.h
@@ -231,9 +231,9 @@ public:
 class TrexStatelessDpUpdate : public TrexStatelessCpToDpMsgBase {
 public:
 
-    TrexStatelessDpUpdate(uint8_t port_id, double mul)  {
+    TrexStatelessDpUpdate(uint8_t port_id, double factor)  {
         m_port_id = port_id;
-        m_mul = mul;
+        m_factor = factor;
     }
 
     virtual bool handle(TrexStatelessDpCore *dp_core);
@@ -242,7 +242,7 @@ public:
 
 private:
     uint8_t  m_port_id;
-    double   m_mul;
+    double   m_factor;
 };