diff options
Diffstat (limited to 'scripts')
32 files changed, 34236 insertions, 1646 deletions
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 6793a4ca..00304886 100644 --- a/scripts/automation/trex_control_plane/client/trex_async_client.py +++ b/scripts/automation/trex_control_plane/client/trex_async_client.py @@ -21,13 +21,14 @@ from common.trex_stats import * from common.trex_streams import * # basic async stats class -class TrexAsyncStats(object): +class CTRexAsyncStats(object): def __init__ (self): self.ref_point = None self.current = {} self.last_update_ts = datetime.datetime.now() - def __format_num (self, size, suffix = ""): + @staticmethod + def format_num (size, suffix = ""): for unit in ['','K','M','G','T','P']: if abs(size) < 1000.0: @@ -45,9 +46,12 @@ class TrexAsyncStats(object): if self.ref_point == None: self.ref_point = self.current + + def clear(self): + self.ref_point = self.current - def get (self, field, format = False, suffix = ""): + def get(self, field, format=False, suffix=""): if not field in self.current: return "N/A" @@ -55,17 +59,16 @@ class TrexAsyncStats(object): if not format: return self.current[field] else: - return self.__format_num(self.current[field], suffix) - + return self.format_num(self.current[field], suffix) - def get_rel (self, field, format = False, suffix = ""): + def get_rel (self, field, format=False, suffix=""): if not field in self.current: return "N/A" if not format: return (self.current[field] - self.ref_point[field]) else: - return self.__format_num(self.current[field] - self.ref_point[field], suffix) + return self.format_num(self.current[field] - self.ref_point[field], suffix) # return true if new data has arrived in the past 2 seconds @@ -74,28 +77,28 @@ class TrexAsyncStats(object): return (delta_ms < 2000) # describes the general stats provided by TRex -class TrexAsyncStatsGeneral(TrexAsyncStats): +class CTRexAsyncStatsGeneral(CTRexAsyncStats): def __init__ (self): - super(TrexAsyncStatsGeneral, self).__init__() + super(CTRexAsyncStatsGeneral, self).__init__() # per port stats -class TrexAsyncStatsPort(TrexAsyncStats): +class CTRexAsyncStatsPort(CTRexAsyncStats): def __init__ (self): - super(TrexAsyncStatsPort, self).__init__() + super(CTRexAsyncStatsPort, self).__init__() def get_stream_stats (self, stream_id): return None # stats manager -class TrexAsyncStatsManager(): +class CTRexAsyncStatsManager(): def __init__ (self): - self.general_stats = TrexAsyncStatsGeneral() + self.general_stats = CTRexAsyncStatsGeneral() self.port_stats = {} - def get_general_stats (self): + def get_general_stats(self): return self.general_stats def get_port_stats (self, port_id): @@ -106,10 +109,10 @@ class TrexAsyncStatsManager(): return self.port_stats[str(port_id)] - def update (self, data): + def update(self, data): self.__handle_snapshot(data) - def __handle_snapshot (self, snapshot): + def __handle_snapshot(self, snapshot): general_stats = {} port_stats = {} @@ -140,7 +143,7 @@ class TrexAsyncStatsManager(): for port_id, data in port_stats.iteritems(): if not port_id in self.port_stats: - self.port_stats[port_id] = TrexAsyncStatsPort() + self.port_stats[port_id] = CTRexAsyncStatsPort() self.port_stats[port_id].update(data) @@ -149,49 +152,115 @@ class TrexAsyncStatsManager(): 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 = TrexAsyncStatsManager() + 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() + self.connected = True - def run (self): + # 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 False, "*** [subscriber] - no data flow from server at : " + self.tr - # Socket to talk to server - self.context = zmq.Context() - self.socket = self.context.socket(zmq.SUB) + return True, "" + + # 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, 3000) + self.socket.setsockopt(zmq.RCVTIMEO, 5000) + + got_data = False while self.active: try: - line = self.socket.recv_string(); - self.stateless_client.on_async_alive() + 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: - self.stateless_client.on_async_dead() + + # 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'] @@ -201,6 +270,17 @@ class CTRexAsyncClient(): self.__dispatch(name, type, data) + + # 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 @@ -208,12 +288,11 @@ class CTRexAsyncClient(): def get_raw_snapshot (self): return self.raw_snapshot - # dispatch the message to the right place 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": self.stateless_client.handle_async_event(type, data) @@ -221,7 +300,3 @@ class CTRexAsyncClient(): pass - def stop (self): - self.active = False - self.t.join() - diff --git a/scripts/automation/trex_control_plane/client/trex_client.py b/scripts/automation/trex_control_plane/client/trex_client.py index 160abdec..49807014 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 = 30, user = None, trex_development = False, **trex_cmd_options): """ Request to start a TRex run on server. @@ -125,13 +125,15 @@ 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: # specify a test should take at least 30 seconds long. 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 + self.result_obj.clear_results() try: issue_time = time.time() @@ -544,7 +546,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 +558,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 +771,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 +1037,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..4f82e86a --- /dev/null +++ b/scripts/automation/trex_control_plane/client/trex_port.py @@ -0,0 +1,411 @@ + +from collections import namedtuple +from common.trex_types import * +from common import trex_stats + +# 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): + 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.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, + "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) + self.handler = None + + if rc.success: + 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 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 not rc.success: + return self.err(rc.data) + + # 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, 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() + + # 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, data = self.transmit_batch(batch) + + if not rc: + return self.err(data) + + # 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, data = self.transmit("remove_stream", params) + if not rc: + return self.err(data) + + 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, data = self.transmit("remove_all_streams", params) + if not rc: + return self.err(data) + + 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, 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} + + 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") + + 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 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, data = self.transmit("validate", params) + if not rc: + return self.err(data) + + self.profile = 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 c1dea9eb..899805cf 100755 --- a/scripts/automation/trex_control_plane/client/trex_stateless_client.py +++ b/scripts/automation/trex_control_plane/client/trex_stateless_client.py @@ -10,409 +10,88 @@ except ImportError: from client_utils.jsonrpc_client import JsonRpcClient, BatchMessage from client_utils.packet_builder import CTRexPktBuilder import json -from common.trex_stats import * + from common.trex_streams import * from collections import namedtuple from common.text_opts import * -import parsing_opts +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()])) +########## utlity ############ +def mult_to_factor (mult, max_bps, max_pps, line_util): + if mult['type'] == 'raw': + return mult['value'] - except Exception as e: - return None + if mult['type'] == 'bps': + return mult['value'] / max_bps - return self.get_stream_pack(stream_pack_name) + if mult['type'] == 'pps': + return mult['value'] / max_pps - def load_streams(self, name, LoadedStreamList_obj): - if name in self.stream_packs: - return False - else: - self.stream_packs[name] = LoadedStreamList_obj - return True + if mult['type'] == 'percentage': + return mult['value'] / line_util - 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() +class CTRexStatelessClient(object): + """docstring for CTRexStatelessClient""" - def stream_pack_exists (self, name): - return name in self.get_loaded_streams_names() + # verbose levels + VERBOSE_SILENCE = 0 + VERBOSE_REGULAR = 1 + VERBOSE_HIGH = 2 + + def __init__(self, username, server="localhost", sync_port = 5050, async_port = 4500, virtual=False): + super(CTRexStatelessClient, self).__init__() - 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 - - 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 = {} - - def err(self, msg): - return RC_ERR("port {0} : {1}".format(self.port_id, msg)) - - def ok(self): - return RC_OK() + self.user = username - def get_speed_bps (self): - return (self.speed * 1000 * 1000 * 1000) + self.comm_link = CTRexStatelessClient.CCommLink(server, sync_port, virtual, self.prn_func) - # take the port - def acquire(self, force = False): - params = {"port_id": self.port_id, - "user": self.user, - "force": force} + # default verbose level + self.verbose = self.VERBOSE_REGULAR - 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) + self.ports = {} + self._connection_info = {"server": server, + "sync_port": sync_port, + "async_port": async_port} + self.system_info = {} + self.server_version = {} + self.__err_log = None + self.async_client = CTRexAsyncClient(server, async_port, self, self.prn_func) - # release the port - def release(self): - params = {"port_id": self.port_id, - "handler": self.handler} + self.streams_db = CStreamsDB() + self.global_stats = trex_stats.CGlobalStats(self._connection_info, + self.server_version, + self.ports) + self.stats_generator = trex_stats.CTRexStatsGenerator(self.global_stats, + self.ports) - 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'])) + self.events = [] - return self.ok() + self.read_only = False + self.connected = False - # 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} - - rc, data = self.transmit("remove_all_streams", params) - if not rc: - return self.err(data) - - self.streams = {} - - 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, 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} - - 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") - - 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() - - ################# 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.comm_link = CTRexStatelessClient.CCommLink(server, sync_port, virtual) - self.verbose = False - self.ports = [] - self._conn_handler = {} - self._active_ports = set() - self._system_info = None - self._server_version = None - self.__err_log = None - - self._async_client = CTRexAsyncClient(server, async_port, self) - self.streams_db = CStreamsDB() - self.connected = False + # returns the port object + def get_port (self, port_id): + return self.ports.get(port_id, None) - self.events = [] + def get_server (self): + return self.comm_link.get_server() ################# events handler ###################### def add_event_log (self, msg, ev_type, show = False): @@ -427,7 +106,37 @@ class CTRexStatelessClient(object): self.events.append("{:<10} - {:^8} - {:}".format(st, prefix, format_text(msg, 'bold'))) if show: - print format_text("\n{:^8} - {:}".format(prefix, format_text(msg, 'bold'))) + 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 = {} + + # filter the values per port and general + for key, value in dump_data.iteritems(): + # match a pattern of ports + m = re.search('(.*)\-([0-8])', key) + if m: + port_id = int(m.group(2)) + field_name = m.group(1) + if self.ports.has_key(port_id): + if not port_id in port_stats: + port_stats[port_id] = {} + port_stats[port_id][field_name] = value + else: + continue + else: + # no port match - general stats + global_stats[key] = value + + # update the general object with the snapshot + self.global_stats.update(global_stats) + # update all ports + 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 @@ -438,6 +147,7 @@ class CTRexStatelessClient(object): if (type == 0): port_id = int(data['port_id']) ev = "Port {0} has started".format(port_id) + self.async_event_port_started(port_id) # port stopped elif (type == 1): @@ -448,21 +158,47 @@ class CTRexStatelessClient(object): 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} 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): + port_id = int(data['port_id']) + ev = "Port {0} was forcely taken".format(port_id) + + # 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 @@ -474,8 +210,26 @@ class CTRexStatelessClient(object): 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 @@ -485,6 +239,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) @@ -517,27 +289,38 @@ 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 + # connect sync channel rc, data = self.comm_link.connect() if not rc: return RC_ERR(data) + # connect async channel + rc, data = self.async_client.connect() + if not rc: + return RC_ERR(data) + # version rc, data = self.transmit("get_version") if not rc: return RC_ERR(data) self.server_version = data + self.global_stats.server_version = data # cache system info rc, data = self.transmit("get_system_info") if not rc: return RC_ERR(data) - self.system_info = data # cache supported commands @@ -551,44 +334,74 @@ class CTRexStatelessClient(object): 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.append(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) + - 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.is_connected(): + if self.connected: msg = 'lost connection to server' self.add_event_log(msg, 'local', True) - - self.disconnect() + self.connected = False def on_async_alive (self): - if not self.is_connected(): - msg = 'server connection restored' - self.add_event_log(msg, 'local', True) - - self.cmd_connect() + pass ########### cached queries (no server traffic) ########### @@ -612,7 +425,7 @@ class CTRexStatelessClient(object): return port_ids def get_stats_async (self): - return self._async_client.get_stats() + return self.async_client.get_stats() def get_connection_port (self): return self.comm_link.port @@ -620,17 +433,50 @@ class CTRexStatelessClient(object): def get_connection_ip (self): return self.comm_link.server - def get_acquired_ports(self): - return [port.port_id for port in self.ports if port.is_acquired()] + 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() + if port_obj.is_acquired()] def get_active_ports(self): - return [port.port_id for port in self.ports if port.is_active()] + return [port_id + 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 @@ -639,21 +485,23 @@ class CTRexStatelessClient(object): return RC(rc, info) - 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 + def get_global_stats(self): + rc, info = self.transmit("get_global_stats") + return RC(rc, info) - return RC_OK() + ########## 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 - ########## port commands ############## # 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) @@ -672,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 @@ -689,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 @@ -794,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 @@ -805,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 @@ -827,12 +690,6 @@ class CTRexStatelessClient(object): def cmd_reset(self): - # sync with the server - rc = self.sync_with_server() - rc.annotate("Syncing with the server:") - if rc.bad(): - return rc - rc = self.acquire(force = True) rc.annotate("Force acquiring all ports:") if rc.bad(): @@ -863,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) @@ -877,52 +734,53 @@ class CTRexStatelessClient(object): # update cmd def cmd_update (self, port_id_list, mult): - # find the relveant ports + # find the relevant ports 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) 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 + + # 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 def cmd_pause (self, port_id_list): - # find the relveant ports + # find the relevant ports 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) 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_OK() - - def cmd_pause_line (self, line): - '''Pause active traffic in specified ports on TRex\n''' - parser = parsing_opts.gen_parser(self, - "pause", - self.cmd_stop_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") + return rc - return self.cmd_pause(opts.ports) # resume cmd @@ -938,28 +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() - - - def cmd_resume_line (self, line): - '''Resume active traffic in specified ports on TRex\n''' - parser = parsing_opts.gen_parser(self, - "resume", - self.cmd_stop_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") - - return self.cmd_resume(opts.ports) + 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)) @@ -981,20 +822,67 @@ 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)) + + 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) + + stats_obj = {} + for stats_type in stats_opts: + stats_obj.update(self.stats_generator.generate_single_statistic(port_id_list, stats_type)) + return stats_obj - return RC_OK() ############## 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 @@ -1006,16 +894,20 @@ class CTRexStatelessClient(object): parsing_opts.FORCE, parsing_opts.STREAM_FROM_PATH_OR_FILE, parsing_opts.DURATION, - parsing_opts.MULTIPLIER_STRICT) + parsing_opts.MULTIPLIER_STRICT, + parsing_opts.DRY_RUN) opts = parser.parse_args(line.split()) if opts is None: - return RC_ERR("bad command line paramters") + return RC_ERR("bad command line parameters") + if opts.dry: + print format_text("\n*** DRY RUN ***", 'bold') + if opts.db: - stream_list = self.stream_db.get_stream_pack(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(): @@ -1035,8 +927,24 @@ class CTRexStatelessClient(object): # if total was set - divide it between the 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, + "resume", + self.cmd_stop_line.__doc__, + parsing_opts.PORT_LIST_WITH_ALL) + + opts = parser.parse_args(line.split()) + if opts is None: + return RC_ERR("bad command line parameters") + + 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, @@ -1046,11 +954,27 @@ class CTRexStatelessClient(object): opts = parser.parse_args(line.split()) if opts is None: - return RC_ERR("bad command line paramters") + return RC_ERR("bad command line parameters") 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, + "pause", + self.cmd_stop_line.__doc__, + parsing_opts.PORT_LIST_WITH_ALL) + + opts = parser.parse_args(line.split()) + if opts is None: + return RC_ERR("bad command line parameters") + + 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, @@ -1071,11 +995,74 @@ class CTRexStatelessClient(object): 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 + parser = parsing_opts.gen_parser(self, + "clear", + self.cmd_clear_line.__doc__, + parsing_opts.PORT_LIST_WITH_ALL) + + opts = parser.parse_args(line.split()) + + if opts is None: + 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 + parser = parsing_opts.gen_parser(self, + "stats", + self.cmd_stats_line.__doc__, + parsing_opts.PORT_LIST_WITH_ALL, + parsing_opts.STATS_MASK) + + opts = parser.parse_args(line.split()) + + if opts is None: + return RC_ERR("bad command line parameters") + + # determine stats mask + mask = self._get_mask_keys(**self._filter_namespace_args(opts, trex_stats.ALL_STATS_OPTS)) + if not mask: + # set to show all stats if no filter was given + mask = trex_stats.ALL_STATS_OPTS + + 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 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') # a way to exit @@ -1092,7 +1079,7 @@ class CTRexStatelessClient(object): opts = parser.parse_args(line.split()) if opts is None: - return RC_ERR("bad command line paramters") + return RC_ERR("bad command line parameters") delay_sec = opts.duration if (opts.duration > 0) else 1 @@ -1151,17 +1138,33 @@ class CTRexStatelessClient(object): return True + + ################################# + # ------ private methods ------ # + @staticmethod + def _get_mask_keys(ok_values={True}, **kwargs): + masked_keys = set() + for key, val in kwargs.iteritems(): + if val in ok_values: + masked_keys.add(key) + return masked_keys + + @staticmethod + 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): @@ -1170,6 +1173,9 @@ class CTRexStatelessClient(object): else: return True + def get_server (self): + return self.server + def set_verbose(self, mode): self.verbose = mode return self.rpc_link.set_verbose(mode) @@ -1211,5 +1217,3 @@ class CTRexStatelessClient(object): if __name__ == "__main__": pass - - diff --git a/scripts/automation/trex_control_plane/client_utils/external_packages.py b/scripts/automation/trex_control_plane/client_utils/external_packages.py index e2bb37a5..3c6eb449 100755 --- a/scripts/automation/trex_control_plane/client_utils/external_packages.py +++ b/scripts/automation/trex_control_plane/client_utils/external_packages.py @@ -9,7 +9,8 @@ PATH_TO_PYTHON_LIB = os.path.abspath(os.path.join(ROOT_PATH, os.pardir, os.pard CLIENT_UTILS_MODULES = ['zmq', 'dpkt-1.8.6', - 'PyYAML-3.01/lib' + 'PyYAML-3.01/lib', + 'texttable-0.8.4' ] def import_client_utils_modules(): 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 b826f02f..ce98fbc6 100755 --- a/scripts/automation/trex_control_plane/client_utils/jsonrpc_client.py +++ b/scripts/automation/trex_control_plane/client_utils/jsonrpc_client.py @@ -37,7 +37,7 @@ class BatchMessage(object): msg = json.dumps(self.batch_list) - rc, resp_list = self.rpc_client.send_raw_msg(msg, block = False) + rc, resp_list = self.rpc_client.send_raw_msg(msg) if len(self.batch_list) == 1: return CmdResponse(True, [CmdResponse(rc, resp_list)]) else: @@ -47,7 +47,7 @@ class BatchMessage(object): # 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 +56,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 +114,7 @@ class JsonRpcClient(object): def invoke_rpc_method (self, method_name, params = {}): if not self.connected: - return False, "Not connected to server" + return CmdResponse(False, "Not connected to server") id, msg = self.create_jsonrpc_v2(method_name, params) @@ -130,11 +132,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 CmdResponse(False, "*** [RPC] - Failed to send message to server") tries = 0 @@ -143,11 +144,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 CmdResponse(False, "*** [RPC] - Failed to get server response") self.verbose_msg("Server Response:\n\n" + self.pretty_json(response) + "\n") @@ -174,7 +174,7 @@ class JsonRpcClient(object): def process_single_response (self, response_json): if (response_json.get("jsonrpc") != "2.0"): - return False, "Malfromed Response ({0})".format(str(response)) + return False, "Malformed Response ({0})".format(str(response_json)) # error reported by server if ("error" in response_json): @@ -185,7 +185,7 @@ class JsonRpcClient(object): # if no error there should be a result if ("result" not in response_json): - return False, "Malformed Response ({0})".format(str(response)) + return False, "Malformed Response ({0})".format(str(response_json)) return True, response_json["result"] @@ -203,7 +203,8 @@ class JsonRpcClient(object): else: return False, "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,7 +216,11 @@ 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: @@ -223,8 +228,8 @@ class JsonRpcClient(object): except zmq.error.ZMQError as e: return False, "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 diff --git a/scripts/automation/trex_control_plane/console/parsing_opts.py b/scripts/automation/trex_control_plane/client_utils/parsing_opts.py index d7bf583a..6f9b4c6d 100755 --- a/scripts/automation/trex_control_plane/console/parsing_opts.py +++ b/scripts/automation/trex_control_plane/client_utils/parsing_opts.py @@ -20,7 +20,14 @@ SERVER_IP = 8 STREAM_FROM_PATH_OR_FILE = 9 DURATION = 10 FORCE = 11 -TOTAL = 12 +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 @@ -198,13 +205,43 @@ 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"}), + + PORT_STATS: ArgumentPack(['-p'], + {'action': 'store_true', + 'help': "Fetch only port statistics"}), + + PORT_STATUS: ArgumentPack(['--ps'], + {'action': 'store_true', + 'help': "Fetch only port status data"}), + + # advanced options PORT_LIST_WITH_ALL: ArgumentGroup(MUTEX, [PORT_LIST, ALL_PORTS], {'required': True}), STREAM_FROM_PATH_OR_FILE: ArgumentGroup(MUTEX, [FILE_PATH, FILE_FROM_DB], - {'required': True}) + {'required': True}), + STATS_MASK: ArgumentGroup(MUTEX, [GLOBAL_STATS, + PORT_STATS, + PORT_STATUS], + {}) } diff --git a/scripts/automation/trex_control_plane/client_utils/text_tables.py b/scripts/automation/trex_control_plane/client_utils/text_tables.py new file mode 100644 index 00000000..2debca38 --- /dev/null +++ b/scripts/automation/trex_control_plane/client_utils/text_tables.py @@ -0,0 +1,34 @@ + +import external_packages +from texttable import Texttable +from common.text_opts import format_text + +class TRexTextTable(Texttable): + + def __init__(self): + Texttable.__init__(self) + # set class attributes so that it'll be more like TRex standard output + self.set_chars(['-', '|', '-', '-']) + self.set_deco(Texttable.HEADER | Texttable.VLINES) + +class TRexTextInfo(Texttable): + + def __init__(self): + Texttable.__init__(self) + # set class attributes so that it'll be more like TRex standard output + self.set_chars(['-', ':', '-', '-']) + self.set_deco(Texttable.VLINES) + +def generate_trex_stats_table(): + pass + +def print_table_with_header(texttable_obj, header=""): + header = header.replace("_", " ").title() + print format_text(header, 'cyan', 'underline') + "\n" + print texttable_obj.draw() + "\n" + + pass + +if __name__ == "__main__": + pass + 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 b7e768c1..20255f41 100755 --- a/scripts/automation/trex_control_plane/common/trex_stats.py +++ b/scripts/automation/trex_control_plane/common/trex_stats.py @@ -1,59 +1,305 @@ #!/router/bin/python +from collections import namedtuple, OrderedDict +from client_utils import text_tables +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} -class CTRexStatsManager(object): +ExportableStats = namedtuple('ExportableStats', ['raw_data', 'text_table']) - def __init__(self, *args): - for stat_type in args: - # register stat handler for each stats type - setattr(self, stat_type, CTRexStatsManager.CSingleStatsHandler()) - def __getitem__(self, item): - stats_obj = getattr(self, item) - if stats_obj: - return stats_obj.get_stats() +class CTRexStatsGenerator(object): + """ + This object is responsible of generating stats from objects maintained at + CTRexStatelessClient and the ports. + """ + + def __init__(self, global_stats_ref, ports_dict_ref): + self._global_stats = global_stats_ref + self._ports_dict = ports_dict_ref + + def generate_single_statistic(self, port_id_list, statistic_type): + if statistic_type == GLOBAL_STATS: + return self._generate_global_stats() + elif statistic_type == PORT_STATS: + return self._generate_port_stats(port_id_list) + pass + elif statistic_type == PORT_STATUS: + return self._generate_port_status(port_id_list) else: - return None + # ignore by returning empty object + return {} - class CSingleStatsHandler(object): + def _generate_global_stats(self): + # stats_obj = self._async_stats.get_general_stats() + stats_data = self._global_stats.generate_stats() - def __init__(self): - self._stats = {} + # build table representation + stats_table = text_tables.TRexTextInfo() + stats_table.set_cols_align(["l", "l"]) + stats_table.add_rows([[k.replace("_", " ").title(), v] + for k, v in stats_data.iteritems()], + header=False) + + return {"global_statistics": ExportableStats(stats_data, stats_table)} + + def _generate_port_stats(self, port_id_list): + relevant_ports = self.__get_relevant_ports(port_id_list) + + return_stats_data = {} + per_field_stats = OrderedDict([("owner", []), + ("state", []), + ("--", []), + ("opackets", []), + ("obytes", []), + ("ipackets", []), + ("ibytes", []), + ("ierrors", []), + ("oerrors", []), + ("tx-bytes", []), + ("rx-bytes", []), + ("tx-pkts", []), + ("rx-pkts", []), + ("---", []), + ("Tx bps", []), + ("Rx bps", []), + ("----", []), + ("Tx pps", []), + ("Rx pps", []) + ] + ) + + for port_obj in relevant_ports: + # fetch port data + port_stats = port_obj.generate_port_stats() + + # populate to data structures + return_stats_data[port_obj.port_id] = port_stats + self.__update_per_field_dict(port_stats, per_field_stats) + + 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) + stats_table.header(["port"] + [port.port_id + for port in relevant_ports]) + + return {"port_statistics": ExportableStats(return_stats_data, stats_table)} + + def _generate_port_status(self, port_id_list): + relevant_ports = self.__get_relevant_ports(port_id_list) + + return_stats_data = {} + per_field_status = OrderedDict([("port-type", []), + ("maximum", []), + ("port-status", []) + ] + ) + + for port_obj in relevant_ports: + # fetch port data + # port_stats = self._async_stats.get_port_stats(port_obj.port_id) + port_status = port_obj.generate_port_status() + + # populate to data structures + return_stats_data[port_obj.port_id] = port_status + + self.__update_per_field_dict(port_status, per_field_status) + + 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) + stats_table.header(["port"] + [port.port_id + for port in relevant_ports]) + + return {"port_status": ExportableStats(return_stats_data, stats_table)} + + def __get_relevant_ports(self, port_id_list): + # fetch owned ports + ports = [port_obj + for _, port_obj in self._ports_dict.iteritems() + 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') + ports = ports[:4] + return ports + + def __update_per_field_dict(self, dict_src_data, dict_dest_ref): + for key, val in dict_src_data.iteritems(): + if key in dict_dest_ref: + dict_dest_ref[key].append(val) - def update(self, obj_id, stats_obj): - assert isinstance(stats_obj, CTRexStats) - self._stats[obj_id] = stats_obj - def get_stats(self, obj_id=None): - if obj_id: - return copy.copy(self._stats.pop(obj_id)) - else: - return copy.copy(self._stats) class CTRexStats(object): - def __init__(self, **kwargs): - for k, v in kwargs.items(): - setattr(self, k, v) + """ This is an abstract class to represent a stats object """ + + def __init__(self): + self.reference_stats = None + self.latest_stats = {} + self.last_update_ts = time.time() + + + def __getitem__(self, item): + # override this to allow quick and clean access to fields + if not item in self.latest_stats: + return "N/A" + + # item must exist + m = re.search('_(([a-z])ps)$', item) + if m: + # this is a non-relative item + unit = m.group(2) + if unit == "b": + return self.get(item, format=True, suffix="b/sec") + elif unit == "p": + return self.get(item, format=True, suffix="pkt/sec") + else: + return self.get(item, format=True, suffix=m.group(1)) + + m = re.search('^[i|o](a-z+)$', item) + if m: + # this is a non-relative item + type = m.group(1) + if type == "bytes": + return self.get_rel(item, format=True, suffix="B") + elif type == "packets": + return self.get_rel(item, format=True, suffix="pkts") + else: + # do not format with suffix + return self.get_rel(item, format=True) + + # can't match to any known pattern, return N/A + return "N/A" + + @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) + size /= 1000.0 + return "NaN" + + def generate_stats(self): + # must be implemented by designated classes (such as port/ global stats) + raise NotImplementedError() + + def update(self, snapshot): + # update + self.latest_stats = snapshot + + 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" + if not format: + return self.latest_stats[field] + else: + return self.format_num(self.latest_stats[field], suffix) + + 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: + return self.format_num(self.latest_stats[field] - self.reference_stats[field], suffix) class CGlobalStats(CTRexStats): - def __init__(self, **kwargs): - super(CGlobalStats, self).__init__(kwargs) - pass + pass + + def __init__(self, connection_info, server_version, ports_dict_ref): + super(CGlobalStats, self).__init__() + self.connection_info = connection_info + self.server_version = server_version + self._ports_dict = ports_dict_ref + def generate_stats(self): + return OrderedDict([("connection", "{host}, Port {port}".format(host=self.connection_info.get("server"), + port=self.connection_info.get("sync_port"))), + ("version", "{ver}, UUID: {uuid}".format(ver=self.server_version.get("version", "N/A"), + uuid="N/A")), + ("cpu_util", "{0}%".format(self.get("m_cpu_util"))), + ("total_tx", self.get("m_tx_bps", format=True, suffix="b/sec")), + ("total_rx", self.get("m_rx_bps", format=True, suffix="b/sec")), + ("total_pps", self.format_num(self.get("m_tx_pps") + self.get("m_rx_pps"), + suffix="pkt/sec")), + ("total_streams", sum([len(port_obj.streams) + for _, port_obj in self._ports_dict.iteritems()])), + ("active_ports", sum([port_obj.is_active() + for _, port_obj in self._ports_dict.iteritems()])) + ] + ) class CPortStats(CTRexStats): - def __init__(self, **kwargs): - super(CPortStats, self).__init__(kwargs) - pass + pass + + def __init__(self, port_obj): + super(CPortStats, self).__init__() + self._port_obj = port_obj + + def generate_stats(self): + return {"owner": self._port_obj.user, + "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 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"), + } -class CStreamStats(CTRexStats): - def __init__(self, **kwargs): - super(CStreamStats, self).__init__(kwargs) - pass if __name__ == "__main__": 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..3de36e4c --- /dev/null +++ b/scripts/automation/trex_control_plane/common/trex_types.py @@ -0,0 +1,66 @@ + +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): + return [x.data if x.rc else "" for x in self.rc_list] + + def err (self): + return [x.data if not x.rc else "" for x in self.rc_list] + + 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 e537c306..325ba514 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 @@ -33,8 +33,9 @@ from common.trex_streams import * from client.trex_stateless_client import CTRexStatelessClient from common.text_opts import * from client_utils.general_utils import user_input, get_current_user -import trex_status -import parsing_opts +from client_utils import parsing_opts +import trex_tui +from functools import wraps __version__ = "1.1" @@ -113,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" @@ -129,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 + + ret = f(*args) + return ret + + 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()) def register_main_console_methods(self): main_names = set(self.trex_console.get_names()).difference(set(dir(self.__class__))) @@ -141,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 @@ -207,13 +255,9 @@ class TRexConsole(TRexGeneralCmd): ####################### shell commands ####################### + @verify_connected def do_ping (self, line): '''Ping the server\n''' - - if not self.stateless_client.is_connected(): - print format_text("\nNot connected to server\n", 'bold') - return - rc = self.stateless_client.cmd_ping() if rc.bad(): return @@ -227,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: @@ -276,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 @@ -303,13 +343,10 @@ 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''' - if not self.stateless_client.is_connected(): - print format_text("\nNot connected to server\n", 'bold') - return - self.stateless_client.cmd_start_line(line) @@ -317,62 +354,72 @@ class TRexConsole(TRexGeneralCmd): self.do_start("-h") ############# stop + @verify_connected_and_rw def do_stop(self, line): '''stops port(s) transmitting traffic\n''' - if not self.stateless_client.is_connected(): - print format_text("\nNot connected to server\n", 'bold') - return - 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''' - if not self.stateless_client.is_connected(): - print format_text("\nNot connected to server\n", 'bold') - return - 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''' - if not self.stateless_client.is_connected(): - print format_text("\nNot connected to server\n", 'bold') - return - self.stateless_client.cmd_pause_line(line) ############# resume + @verify_connected_and_rw def do_resume(self, line): '''resume port(s) transmitting traffic\n''' - if not self.stateless_client.is_connected(): - print format_text("\nNot connected to server\n", 'bold') - return - 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_line(line) - if not self.stateless_client.is_connected(): - print format_text("\nNot connected to server\n", 'bold') - return - self.stateless_client.cmd_reset() + ######### 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) + + + 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) + + def help_clear(self): + self.do_clear("-h") def help_events (self): @@ -404,15 +451,28 @@ class TRexConsole(TRexGeneralCmd): 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 - self.do_verbose('off') - trex_status.show_trex_status(self.stateless_client) + if opts.xterm: + subprocess.Popen(['xterm', '-geometry', '105x40', '-e', './trex-console', '-t']) + return + + save_verbose = self.stateless_client.get_verbose() + + self.stateless_client.set_verbose(self.stateless_client.VERBOSE_SILENCE) + self.tui.show() + self.stateless_client.set_verbose(save_verbose) # quit function def do_quit(self, line): @@ -504,6 +564,10 @@ 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) + return parser @@ -513,10 +577,22 @@ def main(): # Stateless client connection stateless_client = CTRexStatelessClient(options.user, options.server, options.port, options.pub) - rc = stateless_client.cmd_connect() + + 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: @@ -524,11 +600,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_status.py b/scripts/automation/trex_control_plane/console/trex_status.py index 869812a1..cdf3fb69 100644 --- a/scripts/automation/trex_control_plane/console/trex_status.py +++ b/scripts/automation/trex_control_plane/console/trex_status.py @@ -385,7 +385,7 @@ class TrexStatusCommands(): # # # -class TrexStatus(): +class CTRexStatus(): def __init__ (self, stdscr, stateless_client): self.stdscr = stdscr @@ -494,7 +494,7 @@ class TrexStatus(): self.stats_panel.panel.top() self.stats_panel.draw() - panel.update_panels(); + panel.update_panels() self.stdscr.refresh() sleep(0.01) @@ -506,7 +506,7 @@ def show_trex_status_internal (stdscr, stateless_client): global trex_status if trex_status == None: - trex_status = TrexStatus(stdscr, stateless_client) + trex_status = CTRexStatus(stdscr, stateless_client) trex_status.run() 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..3a89097f --- /dev/null +++ b/scripts/automation/trex_control_plane/console/trex_tui.py @@ -0,0 +1,467 @@ +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 Exception("must implement this") + + def get_key_actions (self): + raise Exception("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') + + + + 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/trex_server.py b/scripts/automation/trex_control_plane/server/trex_server.py index 7dee89e9..9868d6c8 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: @@ -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/external_libs/texttable-0.8.4/LICENSE b/scripts/external_libs/texttable-0.8.4/LICENSE new file mode 100644 index 00000000..65c5ca88 --- /dev/null +++ b/scripts/external_libs/texttable-0.8.4/LICENSE @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. diff --git a/scripts/external_libs/texttable-0.8.4/PKG-INFO b/scripts/external_libs/texttable-0.8.4/PKG-INFO new file mode 100644 index 00000000..a3079ad9 --- /dev/null +++ b/scripts/external_libs/texttable-0.8.4/PKG-INFO @@ -0,0 +1,23 @@ +Metadata-Version: 1.0 +Name: texttable +Version: 0.8.4 +Summary: module for creating simple ASCII tables +Home-page: https://github.com/foutaise/texttable/ +Author: Gerome Fournier +Author-email: jef(at)foutaise.org +License: LGPL +Download-URL: https://github.com/foutaise/texttable/archive/v0.8.4.tar.gz +Description: texttable is a module to generate a formatted text table, using ASCII + characters. +Platform: any +Classifier: Development Status :: 4 - Beta +Classifier: Environment :: Console +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: End Users/Desktop +Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL) +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: POSIX +Classifier: Operating System :: MacOS +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: Text Processing +Classifier: Topic :: Utilities diff --git a/scripts/external_libs/texttable-0.8.4/README.md b/scripts/external_libs/texttable-0.8.4/README.md new file mode 100644 index 00000000..0d9895e8 --- /dev/null +++ b/scripts/external_libs/texttable-0.8.4/README.md @@ -0,0 +1,223 @@ +# texttable + +Python module for creating simple ASCII tables + +## Availability + +This module is available on [PypI](https://pypi.python.org/pypi/texttable/0.8.4), and has been packaged for several Linux/Unix platforms +([Debian](https://packages.debian.org/search?&searchon=names&keywords=python-texttable+), +[FreeBSD](https://www.freebsd.org/cgi/ports.cgi?query=texttable&stype=all), Fedora, Suse...). + +## Documentation + +``` +NAME + texttable - module for creating simple ASCII tables + +FILE + /usr/lib/python2.3/site-packages/texttable.py + +DESCRIPTION + + Example: + + table = Texttable() + table.set_cols_align(["l", "r", "c"]) + table.set_cols_valign(["t", "m", "b"]) + table.add_rows([["Name", "Age", "Nickname"], + ["Mr\nXavier\nHuon", 32, "Xav'"], + ["Mr\nBaptiste\nClement", 1, "Baby"]]) + print table.draw() + "\n" + + table = Texttable() + table.set_deco(Texttable.HEADER) + table.set_cols_dtype(['t', # text + 'f', # float (decimal) + 'e', # float (exponent) + 'i', # integer + 'a']) # automatic + table.set_cols_align(["l", "r", "r", "r", "l"]) + table.add_rows([["text", "float", "exp", "int", "auto"], + ["abcd", "67", 654, 89, 128.001], + ["efghijk", 67.5434, .654, 89.6, 12800000000000000000000.00023], + ["lmn", 5e-78, 5e-78, 89.4, .000000000000128], + ["opqrstu", .023, 5e+78, 92., 12800000000000000000000]]) + print table.draw() + + Result: + + +----------+-----+----------+ + | Name | Age | Nickname | + +==========+=====+==========+ + | Mr | | | + | Xavier | 32 | | + | Huon | | Xav' | + +----------+-----+----------+ + | Mr | | | + | Baptiste | 1 | | + | Clement | | Baby | + +----------+-----+----------+ + + text float exp int auto + =========================================== + abcd 67.000 6.540e+02 89 128.001 + efgh 67.543 6.540e-01 90 1.280e+22 + ijkl 0.000 5.000e-78 89 0.000 + mnop 0.023 5.000e+78 92 1.280e+22 + +CLASSES + class Texttable + | Methods defined here: + | + | __init__(self, max_width=80) + | Constructor + | + | - max_width is an integer, specifying the maximum width of the table + | - if set to 0, size is unlimited, therefore cells won't be wrapped + | + | add_row(self, array) + | Add a row in the rows stack + | + | - cells can contain newlines and tabs + | + | add_rows(self, rows, header=True) + | Add several rows in the rows stack + | + | - The 'rows' argument can be either an iterator returning arrays, + | or a by-dimensional array + | - 'header' specifies if the first row should be used as the header + | of the table + | + | draw(self) + | Draw the table + | + | - the table is returned as a whole string + | + | header(self, array) + | Specify the header of the table + | + | reset(self) + | Reset the instance + | + | - reset rows and header + | + | set_chars(self, array) + | Set the characters used to draw lines between rows and columns + | + | - the array should contain 4 fields: + | + | [horizontal, vertical, corner, header] + | + | - default is set to: + | + | ['-', '|', '+', '='] + | + | set_cols_align(self, array) + | Set the desired columns alignment + | + | - the elements of the array should be either "l", "c" or "r": + | + | * "l": column flushed left + | * "c": column centered + | * "r": column flushed right + | + | set_cols_dtype(self, array) + | Set the desired columns datatype for the cols. + | + | - the elements of the array should be either "a", "t", "f", "e" or "i": + | + | * "a": automatic (try to use the most appropriate datatype) + | * "t": treat as text + | * "f": treat as float in decimal format + | * "e": treat as float in exponential format + | * "i": treat as int + | + | - by default, automatic datatyping is used for each column + | + | set_cols_valign(self, array) + | Set the desired columns vertical alignment + | + | - the elements of the array should be either "t", "m" or "b": + | + | * "t": column aligned on the top of the cell + | * "m": column aligned on the middle of the cell + | * "b": column aligned on the bottom of the cell + | + | set_cols_width(self, array) + | Set the desired columns width + | + | - the elements of the array should be integers, specifying the + | width of each column. For example: + | + | [10, 20, 5] + | + | set_deco(self, deco) + | Set the table decoration + | + | - 'deco' can be a combinaison of: + | + | Texttable.BORDER: Border around the table + | Texttable.HEADER: Horizontal line below the header + | Texttable.HLINES: Horizontal lines between rows + | Texttable.VLINES: Vertical lines between columns + | + | All of them are enabled by default + | + | - example: + | + | Texttable.BORDER | Texttable.HEADER + | + | set_precision(self, width) + | Set the desired precision for float/exponential formats + | + | - width must be an integer >= 0 + | + | - default value is set to 3 + | + | ---------------------------------------------------------------------- + | Data and other attributes defined here: + | + | BORDER = 1 + | + | HEADER = 2 + | + | HLINES = 4 + | + | VLINES = 8 + +DATA + __all__ = ['Texttable', 'ArraySizeError'] + __author__ = 'Gerome Fournier <jef(at)foutaise.org>' + __credits__ = 'Jeff Kowalczyk:\n - textwrap improved import\n ...:\... + __license__ = 'LGPL' + __version__ = '0.8.4' + +VERSION + 0.8.4 + +AUTHOR + Gerome Fournier <jef(at)foutaise.org> + +CREDITS + Jeff Kowalczyk: + - textwrap improved import + - comment concerning header output + + Anonymous: + - add_rows method, for adding rows in one go + + Sergey Simonenko: + - redefined len() function to deal with non-ASCII characters + + Roger Lew: + - columns datatype specifications + + Brian Peterson: + - better handling of unicode errors + + Frank Sachsenheim: + - add Python 2/3-compatibility + + Maximilian Hils: + - fix minor bug for Python 3 compatibility +``` diff --git a/scripts/external_libs/texttable-0.8.4/setup.py b/scripts/external_libs/texttable-0.8.4/setup.py new file mode 100644 index 00000000..eb8c9e3a --- /dev/null +++ b/scripts/external_libs/texttable-0.8.4/setup.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python +# +# texttable - module for creating simple ASCII tables +# Copyright (C) 2003-2015 Gerome Fournier <jef(at)foutaise.org> +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +DESCRIPTION = "module for creating simple ASCII tables" + +LONG_DESCRIPTION = """\ +texttable is a module to generate a formatted text table, using ASCII +characters.""" + +import sys + +from distutils.core import setup +if sys.version < '2.2.3': + from distutils.dist import DistributionMetadata + DistributionMetadata.classifiers = None + DistributionMetadata.download_url = None + +setup( + name = "texttable", + version = "0.8.4", + author = "Gerome Fournier", + author_email = "jef(at)foutaise.org", + url = "https://github.com/foutaise/texttable/", + download_url = "https://github.com/foutaise/texttable/archive/v0.8.4.tar.gz", + license = "LGPL", + py_modules = ["texttable"], + description = DESCRIPTION, + long_description = LONG_DESCRIPTION, + platforms = "any", + classifiers = [ + 'Development Status :: 4 - Beta', + 'Environment :: Console', + 'Intended Audience :: Developers', + 'Intended Audience :: End Users/Desktop', + 'License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)', + 'Operating System :: Microsoft :: Windows', + 'Operating System :: POSIX', + 'Operating System :: MacOS', + 'Topic :: Software Development :: Libraries :: Python Modules', + 'Topic :: Text Processing', + 'Topic :: Utilities', + ] +) diff --git a/scripts/external_libs/texttable-0.8.4/texttable.py b/scripts/external_libs/texttable-0.8.4/texttable.py new file mode 100644 index 00000000..775a43e5 --- /dev/null +++ b/scripts/external_libs/texttable-0.8.4/texttable.py @@ -0,0 +1,607 @@ +#!/usr/bin/env python +# +# texttable - module for creating simple ASCII tables +# Copyright (C) 2003-2015 Gerome Fournier <jef(at)foutaise.org> +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + +"""module for creating simple ASCII tables + + +Example: + + table = Texttable() + table.set_cols_align(["l", "r", "c"]) + table.set_cols_valign(["t", "m", "b"]) + table.add_rows([["Name", "Age", "Nickname"], + ["Mr\\nXavier\\nHuon", 32, "Xav'"], + ["Mr\\nBaptiste\\nClement", 1, "Baby"]]) + print table.draw() + "\\n" + + table = Texttable() + table.set_deco(Texttable.HEADER) + table.set_cols_dtype(['t', # text + 'f', # float (decimal) + 'e', # float (exponent) + 'i', # integer + 'a']) # automatic + table.set_cols_align(["l", "r", "r", "r", "l"]) + table.add_rows([["text", "float", "exp", "int", "auto"], + ["abcd", "67", 654, 89, 128.001], + ["efghijk", 67.5434, .654, 89.6, 12800000000000000000000.00023], + ["lmn", 5e-78, 5e-78, 89.4, .000000000000128], + ["opqrstu", .023, 5e+78, 92., 12800000000000000000000]]) + print table.draw() + +Result: + + +----------+-----+----------+ + | Name | Age | Nickname | + +==========+=====+==========+ + | Mr | | | + | Xavier | 32 | | + | Huon | | Xav' | + +----------+-----+----------+ + | Mr | | | + | Baptiste | 1 | | + | Clement | | Baby | + +----------+-----+----------+ + + text float exp int auto + =========================================== + abcd 67.000 6.540e+02 89 128.001 + efgh 67.543 6.540e-01 90 1.280e+22 + ijkl 0.000 5.000e-78 89 0.000 + mnop 0.023 5.000e+78 92 1.280e+22 +""" + +__all__ = ["Texttable", "ArraySizeError"] + +__author__ = 'Gerome Fournier <jef(at)foutaise.org>' +__license__ = 'LGPL' +__version__ = '0.8.4' +__credits__ = """\ +Jeff Kowalczyk: + - textwrap improved import + - comment concerning header output + +Anonymous: + - add_rows method, for adding rows in one go + +Sergey Simonenko: + - redefined len() function to deal with non-ASCII characters + +Roger Lew: + - columns datatype specifications + +Brian Peterson: + - better handling of unicode errors + +Frank Sachsenheim: + - add Python 2/3-compatibility + +Maximilian Hils: + - fix minor bug for Python 3 compatibility +""" + +import sys +import string + +try: + if sys.version >= '2.3': + import textwrap + elif sys.version >= '2.2': + from optparse import textwrap + else: + from optik import textwrap +except ImportError: + sys.stderr.write("Can't import textwrap module!\n") + raise + +if sys.version >= '2.7': + from functools import reduce + +def len(iterable): + """Redefining len here so it will be able to work with non-ASCII characters + """ + if not isinstance(iterable, str): + return iterable.__len__() + + try: + if sys.version >= '3.0': + return len(str) + else: + return len(unicode(iterable, 'utf')) + except: + return iterable.__len__() + + +class ArraySizeError(Exception): + """Exception raised when specified rows don't fit the required size + """ + + def __init__(self, msg): + self.msg = msg + Exception.__init__(self, msg, '') + + def __str__(self): + return self.msg + + +class Texttable: + + BORDER = 1 + HEADER = 1 << 1 + HLINES = 1 << 2 + VLINES = 1 << 3 + + def __init__(self, max_width=80): + """Constructor + + - max_width is an integer, specifying the maximum width of the table + - if set to 0, size is unlimited, therefore cells won't be wrapped + """ + + if max_width <= 0: + max_width = False + self._max_width = max_width + self._precision = 3 + + self._deco = Texttable.VLINES | Texttable.HLINES | Texttable.BORDER | \ + Texttable.HEADER + self.set_chars(['-', '|', '+', '=']) + self.reset() + + def reset(self): + """Reset the instance + + - reset rows and header + """ + + self._hline_string = None + self._row_size = None + self._header = [] + self._rows = [] + + def set_chars(self, array): + """Set the characters used to draw lines between rows and columns + + - the array should contain 4 fields: + + [horizontal, vertical, corner, header] + + - default is set to: + + ['-', '|', '+', '='] + """ + + if len(array) != 4: + raise ArraySizeError("array should contain 4 characters") + array = [ x[:1] for x in [ str(s) for s in array ] ] + (self._char_horiz, self._char_vert, + self._char_corner, self._char_header) = array + + def set_deco(self, deco): + """Set the table decoration + + - 'deco' can be a combinaison of: + + Texttable.BORDER: Border around the table + Texttable.HEADER: Horizontal line below the header + Texttable.HLINES: Horizontal lines between rows + Texttable.VLINES: Vertical lines between columns + + All of them are enabled by default + + - example: + + Texttable.BORDER | Texttable.HEADER + """ + + self._deco = deco + + def set_cols_align(self, array): + """Set the desired columns alignment + + - the elements of the array should be either "l", "c" or "r": + + * "l": column flushed left + * "c": column centered + * "r": column flushed right + """ + + self._check_row_size(array) + self._align = array + + def set_cols_valign(self, array): + """Set the desired columns vertical alignment + + - the elements of the array should be either "t", "m" or "b": + + * "t": column aligned on the top of the cell + * "m": column aligned on the middle of the cell + * "b": column aligned on the bottom of the cell + """ + + self._check_row_size(array) + self._valign = array + + def set_cols_dtype(self, array): + """Set the desired columns datatype for the cols. + + - the elements of the array should be either "a", "t", "f", "e" or "i": + + * "a": automatic (try to use the most appropriate datatype) + * "t": treat as text + * "f": treat as float in decimal format + * "e": treat as float in exponential format + * "i": treat as int + + - by default, automatic datatyping is used for each column + """ + + self._check_row_size(array) + self._dtype = array + + def set_cols_width(self, array): + """Set the desired columns width + + - the elements of the array should be integers, specifying the + width of each column. For example: + + [10, 20, 5] + """ + + self._check_row_size(array) + try: + array = list(map(int, array)) + if reduce(min, array) <= 0: + raise ValueError + except ValueError: + sys.stderr.write("Wrong argument in column width specification\n") + raise + self._width = array + + def set_precision(self, width): + """Set the desired precision for float/exponential formats + + - width must be an integer >= 0 + + - default value is set to 3 + """ + + if not type(width) is int or width < 0: + raise ValueError('width must be an integer greater then 0') + self._precision = width + + def header(self, array): + """Specify the header of the table + """ + + self._check_row_size(array) + self._header = list(map(str, array)) + + def add_row(self, array): + """Add a row in the rows stack + + - cells can contain newlines and tabs + """ + + self._check_row_size(array) + + if not hasattr(self, "_dtype"): + self._dtype = ["a"] * self._row_size + + cells = [] + for i, x in enumerate(array): + cells.append(self._str(i, x)) + self._rows.append(cells) + + def add_rows(self, rows, header=True): + """Add several rows in the rows stack + + - The 'rows' argument can be either an iterator returning arrays, + or a by-dimensional array + - 'header' specifies if the first row should be used as the header + of the table + """ + + # nb: don't use 'iter' on by-dimensional arrays, to get a + # usable code for python 2.1 + if header: + if hasattr(rows, '__iter__') and hasattr(rows, 'next'): + self.header(rows.next()) + else: + self.header(rows[0]) + rows = rows[1:] + for row in rows: + self.add_row(row) + + def draw(self): + """Draw the table + + - the table is returned as a whole string + """ + + if not self._header and not self._rows: + return + self._compute_cols_width() + self._check_align() + out = "" + if self._has_border(): + out += self._hline() + if self._header: + out += self._draw_line(self._header, isheader=True) + if self._has_header(): + out += self._hline_header() + length = 0 + for row in self._rows: + length += 1 + out += self._draw_line(row) + if self._has_hlines() and length < len(self._rows): + out += self._hline() + if self._has_border(): + out += self._hline() + return out[:-1] + + def _str(self, i, x): + """Handles string formatting of cell data + + i - index of the cell datatype in self._dtype + x - cell data to format + """ + try: + f = float(x) + except: + return str(x) + + n = self._precision + dtype = self._dtype[i] + + if dtype == 'i': + return str(int(round(f))) + elif dtype == 'f': + return '%.*f' % (n, f) + elif dtype == 'e': + return '%.*e' % (n, f) + elif dtype == 't': + return str(x) + else: + if f - round(f) == 0: + if abs(f) > 1e8: + return '%.*e' % (n, f) + else: + return str(int(round(f))) + else: + if abs(f) > 1e8: + return '%.*e' % (n, f) + else: + return '%.*f' % (n, f) + + def _check_row_size(self, array): + """Check that the specified array fits the previous rows size + """ + + if not self._row_size: + self._row_size = len(array) + elif self._row_size != len(array): + raise ArraySizeError("array should contain %d elements" \ + % self._row_size) + + def _has_vlines(self): + """Return a boolean, if vlines are required or not + """ + + return self._deco & Texttable.VLINES > 0 + + def _has_hlines(self): + """Return a boolean, if hlines are required or not + """ + + return self._deco & Texttable.HLINES > 0 + + def _has_border(self): + """Return a boolean, if border is required or not + """ + + return self._deco & Texttable.BORDER > 0 + + def _has_header(self): + """Return a boolean, if header line is required or not + """ + + return self._deco & Texttable.HEADER > 0 + + def _hline_header(self): + """Print header's horizontal line + """ + + return self._build_hline(True) + + def _hline(self): + """Print an horizontal line + """ + + if not self._hline_string: + self._hline_string = self._build_hline() + return self._hline_string + + def _build_hline(self, is_header=False): + """Return a string used to separated rows or separate header from + rows + """ + horiz = self._char_horiz + if (is_header): + horiz = self._char_header + # compute cell separator + s = "%s%s%s" % (horiz, [horiz, self._char_corner][self._has_vlines()], + horiz) + # build the line + l = s.join([horiz * n for n in self._width]) + # add border if needed + if self._has_border(): + l = "%s%s%s%s%s\n" % (self._char_corner, horiz, l, horiz, + self._char_corner) + else: + l += "\n" + return l + + def _len_cell(self, cell): + """Return the width of the cell + + Special characters are taken into account to return the width of the + cell, such like newlines and tabs + """ + + cell_lines = cell.split('\n') + maxi = 0 + for line in cell_lines: + length = 0 + parts = line.split('\t') + for part, i in zip(parts, list(range(1, len(parts) + 1))): + length = length + len(part) + if i < len(parts): + length = (length//8 + 1) * 8 + maxi = max(maxi, length) + return maxi + + def _compute_cols_width(self): + """Return an array with the width of each column + + If a specific width has been specified, exit. If the total of the + columns width exceed the table desired width, another width will be + computed to fit, and cells will be wrapped. + """ + + if hasattr(self, "_width"): + return + maxi = [] + if self._header: + maxi = [ self._len_cell(x) for x in self._header ] + for row in self._rows: + for cell,i in zip(row, list(range(len(row)))): + try: + maxi[i] = max(maxi[i], self._len_cell(cell)) + except (TypeError, IndexError): + maxi.append(self._len_cell(cell)) + items = len(maxi) + length = reduce(lambda x, y: x+y, maxi) + if self._max_width and length + items * 3 + 1 > self._max_width: + maxi = [(self._max_width - items * 3 -1) // items \ + for n in range(items)] + self._width = maxi + + def _check_align(self): + """Check if alignment has been specified, set default one if not + """ + + if not hasattr(self, "_align"): + self._align = ["l"] * self._row_size + if not hasattr(self, "_valign"): + self._valign = ["t"] * self._row_size + + def _draw_line(self, line, isheader=False): + """Draw a line + + Loop over a single cell length, over all the cells + """ + + line = self._splitit(line, isheader) + space = " " + out = "" + for i in range(len(line[0])): + if self._has_border(): + out += "%s " % self._char_vert + length = 0 + for cell, width, align in zip(line, self._width, self._align): + length += 1 + cell_line = cell[i] + fill = width - len(cell_line) + if isheader: + align = "c" + if align == "r": + out += "%s " % (fill * space + cell_line) + elif align == "c": + out += "%s " % (int(fill/2) * space + cell_line \ + + int(fill/2 + fill%2) * space) + else: + out += "%s " % (cell_line + fill * space) + if length < len(line): + out += "%s " % [space, self._char_vert][self._has_vlines()] + out += "%s\n" % ['', self._char_vert][self._has_border()] + return out + + def _splitit(self, line, isheader): + """Split each element of line to fit the column width + + Each element is turned into a list, result of the wrapping of the + string to the desired width + """ + + line_wrapped = [] + for cell, width in zip(line, self._width): + array = [] + for c in cell.split('\n'): + try: + if sys.version >= '3.0': + c = str(c) + else: + c = unicode(c, 'utf') + except UnicodeDecodeError as strerror: + sys.stderr.write("UnicodeDecodeError exception for string '%s': %s\n" % (c, strerror)) + if sys.version >= '3.0': + c = str(c, 'utf', 'replace') + else: + c = unicode(c, 'utf', 'replace') + array.extend(textwrap.wrap(c, width)) + line_wrapped.append(array) + max_cell_lines = reduce(max, list(map(len, line_wrapped))) + for cell, valign in zip(line_wrapped, self._valign): + if isheader: + valign = "t" + if valign == "m": + missing = max_cell_lines - len(cell) + cell[:0] = [""] * int(missing / 2) + cell.extend([""] * int(missing / 2 + missing % 2)) + elif valign == "b": + cell[:0] = [""] * (max_cell_lines - len(cell)) + else: + cell.extend([""] * (max_cell_lines - len(cell))) + return line_wrapped + + +if __name__ == '__main__': + table = Texttable() + table.set_cols_align(["l", "r", "c"]) + table.set_cols_valign(["t", "m", "b"]) + table.add_rows([["Name", "Age", "Nickname"], + ["Mr\nXavier\nHuon", 32, "Xav'"], + ["Mr\nBaptiste\nClement", 1, "Baby"]]) + print(table.draw() + "\n") + + table = Texttable() + table.set_deco(Texttable.HEADER) + table.set_cols_dtype(['t', # text + 'f', # float (decimal) + 'e', # float (exponent) + 'i', # integer + 'a']) # automatic + table.set_cols_align(["l", "r", "r", "r", "l"]) + table.add_rows([["text", "float", "exp", "int", "auto"], + ["abcd", "67", 654, 89, 128.001], + ["efghijk", 67.5434, .654, 89.6, 12800000000000000000000.00023], + ["lmn", 5e-78, 5e-78, 89.4, .000000000000128], + ["opqrstu", .023, 5e+78, 92., 12800000000000000000000]]) + print(table.draw()) 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_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 |