def run():
exit_state = True
logger = PLLogger.GetLogger('methodology')
try:
sequencer = CStcSystem.Instance().GetObject("Sequencer")
if sequencer is None:
raise Exception('Unable to find sequencer object.')
if sequencer.Get('StoppedCommand') == 0:
# case 1: normal end of test
logger.LogInfo("Calling end test.")
ResultInterface.end_test()
else:
if sequencer.Get('TestState').lower() != 'failed':
# case 2: sequencer manually stopped by user
logger.LogInfo("Calling stop test.")
ResultInterface.stop_test()
else:
# case 3: sequencer stopped on error
logger.LogInfo("Calling stop test with error.")
seq_status = sequencer.Get('Status')
pdg.submit_sequencer_execution_error(seq_status)
ResultInterface.stop_test()
except Exception, e:
stack_trace = traceback.format_exc()
logger.LogError(stack_trace)
pdg.submit_command_execution_error('EndOfTestCommand',
str(e),
stack_trace)
ResultInterface.stop_test()
exit_state = False
def create_error_chart():
plLogger = PLLogger.GetLogger('Methodology')
plLogger.LogDebug('AclBasicChartScript.create_error_chart()')
# We want to use the summary (the latter summary with ACL enabled)...
db_list = [pu.get_active_result_db_filename()]
queries = [('Out Of Seq', 'SELECT SUM (OutSeqFrameCount) FROM RxEotStreamResults'),
('Sequence Errors', 'SELECT SUM (DroppedFrameCount + ReorderedFrameCount + '
'FcsErrorFrameCount + PrbsBitErrorCount + DuplicateFrameCount + '
'LateFrameCount) FROM RxEotStreamResults'),
('CRC Errors', 'SELECT SUM(GeneratorCrcErrorFrameCount) FROM GeneratorPortResults'),
('Checksum Errors', 'SELECT SUM(GeneratorL3ChecksumErrorCount + '
'GeneratorL4ChecksumErrorCount) FROM GeneratorPortResults'),
('Data Error', 'SELECT SUM(PrbsBitErrorCount) FROM AnalyzerPortResults')
]
total_error_count = 0
errors = []
captions = []
for caption, query in queries:
error_count = get_data_from_query(db_list, query)[0]
errors.append(error_count)
captions.append(caption)
total_error_count += error_count
if total_error_count == 0:
errors.append(1)
captions.append('No Errors')
template_error_pie['series'][0]['data'] = zip(captions, errors)
template_error_pie['xAxis']['categories'] = captions
result_data = init_chart_data_dict("SUMMARY", template_error_pie)
pdg.submit_provider_data(result_data)
return ""
def Rfc2544ThroughputCreateChart(tagname, b, params):
# plLogger = PLLogger.GetLogger('methodology')
# plLogger.LogDebug("Running Rfc2544ThroughputCreateChart")
db_list = get_dbs(False, True)
# Frame size (X axis names)
q_xcat = str("SELECT FrameSize From MethRfc2544ThroughputFrameRate")
# Found frame rate for each frame size (report 0 if there's dropped frames)
q_fps = str("SELECT CASE WHEN DroppedCount > 0 THEN 0 ELSE FPS END " +
"From MethRfc2544ThroughputFrameRate")
# Get theoretical maximum rate
q_maxfps = str("SELECT round(MaxRate,0) From MethRfc2544ThroughputFrameRate")
# Run the db queries
xcat_data = get_data_from_query(db_list, q_xcat)
fps_data = get_data_from_query(db_list, q_fps)
theoretical_fps_data = get_data_from_query(db_list, q_maxfps)
# Fill in the template with the results
base_template['xAxis']['categories'] = xcat_data
base_template['series'][0]['data'] = fps_data
base_template['series'][1]['data'] = theoretical_fps_data
# This fills in the json file with our chart results?
result_data = init_chart_data_dict("SUMMARY")
pdg.submit_provider_data(result_data)
return ""
def create_tolerance_chart():
plLogger = PLLogger.GetLogger('Methodology')
plLogger.LogDebug('AclPerformanceChartScript.create_tolerance_chart()')
from AclPerformanceData import AclPerformanceData
exp_maxjitter = AclPerformanceData().get_exp_maxjitter()
exp_maxlatency = AclPerformanceData().get_exp_maxlatency()
db_list = get_dbs(True, False)
q_minjitter = form_query_during_blocking_traffic('MIN(MinJitter)')
q_avgjitter = form_query_during_blocking_traffic('AVG(AvgJitter)')
q_maxjitter = form_query_during_blocking_traffic('MAX(MaxJitter)')
q_minlatency = form_query_during_blocking_traffic('MIN(MinLatency)')
q_avglatency = form_query_during_blocking_traffic('AVG(AvgLatency)')
q_maxlatency = form_query_during_blocking_traffic('MAX(MaxLatency)')
q_blocking = form_query_during_blocking_traffic('COUNT(*)', 'Tag.Name="Bad.ttStreamBlock"')
min_jitter_data = get_data_from_query(db_list, q_minjitter)
avg_jitter_data = get_data_from_query(db_list, q_avgjitter)
max_jitter_data = get_data_from_query(db_list, q_maxjitter)
min_latency_data = get_data_from_query(db_list, q_minlatency)
avg_latency_data = get_data_from_query(db_list, q_avglatency)
max_latency_data = get_data_from_query(db_list, q_maxlatency)
nonconformant_data = get_data_from_query(db_list, q_blocking)
q_xcat = str('''SELECT DISTINCT Sb.FixedFrameLength FROM RxEotStreamResults As RxStr
JOIN StreamBlock AS Sb ON RxStr.ParentStreamBlock == Sb.Handle
''')
xcat_data = find_distinct_cats(get_data_from_query(db_list, q_xcat))
count = len(xcat_data)
template_tolerances['series'][0]['data'] = find_msdata(nonconformant_data)
template_tolerances['series'][1]['data'] = find_msdata(min_jitter_data)
template_tolerances['series'][2]['data'] = find_msdata(avg_jitter_data)
template_tolerances['series'][3]['data'] = find_msdata(max_jitter_data)
template_tolerances['series'][4]['data'] = find_msdata(min_latency_data)
template_tolerances['series'][5]['data'] = find_msdata(avg_latency_data)
template_tolerances['series'][6]['data'] = find_msdata(max_latency_data)
template_tolerances['series'][7]['data'] = line(count, exp_maxjitter)
template_tolerances['series'][8]['data'] = line(count, exp_maxlatency)
template_tolerances['xAxis']['categories'] = xcat_data
result_data = init_chart_data_dict("GROUP_1", template_tolerances)
pdg.submit_provider_data(result_data)
return ""
def run(ChartTemplateJsonFileName, Title,
XAxisTitle, XAxisCategories,
YAxisTitle, YAxisCategories,
Series, SeriesDataType, CustomModifier,
UseMultipleResultsDatabases, UseSummary, ReportGroup):
logger = PLLogger.GetLogger('ExportDbChartCommand')
try:
db_list = get_dbs(UseMultipleResultsDatabases, UseSummary)
result_data = init_chart_data_dict(ReportGroup)
series_data = get_series_data(db_list)
add_series_data_list(result_data, series_data)
# If any sql queries were passed in, grab results from db
sql_result_file_list = []
sql_result_file_list.append(db_list[0])
get_sql_data(result_data, sql_result_file_list)
pdg.submit_provider_data(result_data)
# Catch most of them here
except Exception as e:
trace = traceback.format_exc()
logger.LogError(trace)
pdg.submit_command_execution_error('ExportDbChartCommand',
str(e), trace)
return False
except:
trace = traceback.format_exc()
logger.LogError(trace)
pdg.submit_command_execution_error('ExportDbChartCommand',
ProviderConst.UNKNOWN_EXCEPTION_MESSAGE,
trace)
return False
return True
def run(ChartTemplateJsonFileName, Title,
XAxisTitle, XAxisCategories,
YAxisTitle, YAxisCategories,
Series, TemplateModifier, SrcDatabase,
ReportGroup):
logger = PLLogger.GetLogger('methodology')
try:
db_list = get_dbs(SrcDatabase)
result_data = init_chart_data_dict(ReportGroup)
series_data = get_series_data(db_list)
add_series_data_list(result_data, series_data)
get_sql_data(result_data, db_list)
pdg.submit_provider_data(result_data)
# Catch most of them here
except Exception, e:
stack_trace = traceback.format_exc()
logger.LogError(stack_trace)
raise RuntimeError(str(e))
def create_line_rate_chart():
plLogger = PLLogger.GetLogger('Methodology')
plLogger.LogDebug('AclPerformanceChartScript.create_line_rate_chart()')
db_list = get_dbs(True, False)
# The frame size and the frame rates are what we want, the third value is 0 because
# find_msdata uses that value to identify which tuple is the most significant (N/A here).
q_theo_max = '''SELECT Sb.FixedFrameLength, Round( Theo.FrameRate , 0), 0
FROM TheoreticalMaxLineRate AS Theo
JOIN StreamBlock AS Sb ON Theo.FrameSize = Sb.FixedFrameLength
WHERE Theo.MbpsLineRate =
( CASE WHEN (SELECT DISTINCT Ec.LineSpeed FROM EthernetCopper AS Ec
JOIN TxEotStreamResults AS tx ON Tx.ParentHnd = Ec.ParentHnd
WHERE Tx.FrameCount > 0) = 'SPEED_100M' THEN 100 ELSE 1000 END)
LIMIT 1
'''
q_real_max = '''SELECT Sb.FixedFrameLength, SUM(Sb.FpsLoad), 0 FROM StreamBlock AS Sb
JOIN TxEotStreamResults AS Tx ON Tx.ParentStreamBlock = Sb.Handle
WHERE Tx.FrameCount > 0
'''
theo_max = get_data_from_query(db_list, q_theo_max)
real_max = get_data_from_query(db_list, q_real_max)
q_xcat = str("SELECT DISTINCT Sb.FixedFrameLength " +
"FROM RxEotStreamResults As RxStr " +
"JOIN StreamBlock AS Sb " +
"ON RxStr.ParentStreamBlock == Sb.Handle")
xcat_data = get_data_from_query(db_list, q_xcat)
template_line_rate['series'][0]['data'] = find_msdata(theo_max)
template_line_rate['series'][1]['data'] = find_msdata(real_max)
template_line_rate['xAxis']['categories'] = find_distinct_cats(xcat_data)
result_data = init_chart_data_dict("GROUP_1", template_line_rate)
pdg.submit_provider_data(result_data)
return ""
def test_get_formatted_drilldown_data_and_more():
verdict = True
verdictText = 'Not available'
displayName = "My display name"
pass_text = "my pass text"
applyVerdictToSum = False
viewName = 'MyTestDrv'
displays = ['First', 'Second']
report_group = pc.HIGHEST_PRIORITY_REPORT_GROUP
drilldowndataObjects = []
drilldowndata = {}
drilldowndata[pc.SUMMARIZATION_OBJECT] = 'Port.Name'
drilldowndata[pc.COLUMN_DISPLAY_NAMES] = displays
resultviewdata1 = [1, 2]
resultviewdata2 = [3, 4]
resultviewdataList = [resultviewdata1, resultviewdata2]
drilldowndata[pc.ROW] = resultviewdataList
drilldowndataObjects.append(drilldowndata)
drilldowndata = {}
drilldowndata[pc.SUMMARIZATION_OBJECT] = 'Project.Name'
drilldowndata[pc.COLUMN_DISPLAY_NAMES] = displays
resultviewdata = [4, 6]
resultviewdataList = [resultviewdata]
drilldowndata[pc.ROW] = resultviewdataList
drilldowndataObjects.append(drilldowndata)
formatted_data = drv_utils.get_formatted_drilldown_data(drilldowndataObjects)
provider_data = p.get_table_drv_drilldown_data(viewName,
verdict,
verdictText,
applyVerdictToSum,
formatted_data,
report_group,
displayName,
pass_text,
"")
assert provider_data is not None
info = provider_data[pc.INFO]
status = provider_data[pc.STATUS]
data = provider_data[pc.DATA]
logger.info(json.dumps(provider_data, separators=(',', ':'), sort_keys=False))
assert provider_data[pc.CLASS] == EnumDataClass.table_drv_drilldown
assert provider_data[pc.DATA_FORMAT] == EnumDataFormat.table
# verify info
assert info[pc.RESULT_VIEW_NAME] == viewName
assert info[pc.SUMMARIZATION_OBJECT] == 'Project.Name'
assert info[pc.REPORT_GROUP] == pc.HIGHEST_PRIORITY_REPORT_GROUP
assert info[pc.DISPLAY_NAME] == displayName
# verify status
assert status[pc.VERDICT] == EnumVerdict.passed
assert status[pc.VERDICT_TEXT] == pass_text
assert status[pc.EXEC_STATUS] == EnumExecStatus.completed
assert status[pc.APPLY_VERDICT] == applyVerdictToSum
assert len(data[pc.COLUMN_DISPLAY_NAMES]) == 2
assert data[pc.COLUMN_DISPLAY_NAMES][0] == displays[0]
assert data[pc.COLUMN_DISPLAY_NAMES][1] == displays[1]
rows = data[pc.ROW]
assert len(rows) == 1
assert len(rows[0]) == 2
assert rows[0][0] == 4
assert rows[0][1] == 6
assert (pc.LINKS in data) is True
# verify drilldown results
data = data[pc.LINKS]
assert len(data) == 1
data = data[0]
data[pc.TAG] = 'Port.Name'
assert (pc.LINK_DATA in data) is True
data = data[pc.LINK_DATA]
assert data[pc.CLASS] == EnumDataClass.drill_down_results
assert data[pc.DATA_FORMAT] == EnumDataFormat.table
assert data[pc.INFO][pc.SUMMARIZATION_OBJECT] == 'Port.Name'
data = data[pc.DATA]
assert len(data[pc.COLUMN_DISPLAY_NAMES]) == 2
assert data[pc.COLUMN_DISPLAY_NAMES][0] == displays[0]
assert data[pc.COLUMN_DISPLAY_NAMES][1] == displays[1]
rows = data[pc.ROW]
assert len(rows) == 2
assert len(rows[0]) == 2
assert rows[0][0] == 1
assert rows[0][1] == 2
assert rows[1][0] == 3
assert rows[1][1] == 4
assert (pc.LINKS in data) is False
def CreateChart(tagname, b, params):
plLogger = PLLogger.GetLogger('Methodology')
plLogger.LogDebug("Running custom CreateChart script...")
db_list = get_dbs(True, False)
q_minjitter = str("SELECT ROUND(MinJitter*1e-3,3) FROM RxEotStreamResults As RxStr " +
"JOIN StreamBlock AS Sb " +
"ON RxStr.ParentStreamBlock == Sb.Handle")
q_avgjitter = str("SELECT ROUND(AvgJitter*1e-3,3) FROM RxEotStreamResults As RxStr " +
"JOIN StreamBlock AS Sb " +
"ON RxStr.ParentStreamBlock == Sb.Handle")
q_maxjitter = str("SELECT ROUND(MaxJitter*1e-3,3) FROM RxEotStreamResults As RxStr " +
"JOIN StreamBlock AS Sb " +
"ON RxStr.ParentStreamBlock == Sb.Handle")
q_minlatency = str("SELECT ROUND(MinLatency*1e-3,3) FROM RxEotStreamResults As RxStr " +
"JOIN StreamBlock AS Sb " +
"ON RxStr.ParentStreamBlock == Sb.Handle")
q_avglatency = str("SELECT ROUND(AvgLatency*1e-3,3) FROM RxEotStreamResults As RxStr " +
"JOIN StreamBlock AS Sb " +
"ON RxStr.ParentStreamBlock == Sb.Handle")
q_maxlatency = str("SELECT ROUND(MaxLatency*1e-3,3) FROM RxEotStreamResults As RxStr " +
"JOIN StreamBlock AS Sb " +
"ON RxStr.ParentStreamBlock == Sb.Handle")
q_pktloss = str("SELECT TxRes.FrameCount - RxRes.FrameCount " +
"As 'Packet Loss' From RxEotStreamResults As RxRes " +
"JOIN TxEotStreamResults As TxRes " +
"JOIN Streamblock As Sb " +
"ON RxRes.ParentStreamBlock = TxRes.ParentStreamblock " +
"AND TxRes.ParentStreamblock = Sb.Handle")
q_ooopkt = str("SELECT OutSeqFrameCount FROM RxEotStreamResults As RxStr " +
"JOIN StreamBlock AS Sb " +
"ON RxStr.ParentStreamBlock == Sb.Handle")
q_latepkt = str("SELECT LateFrameCount FROM RxEotStreamResults As RxStr " +
"JOIN StreamBlock AS Sb " +
"ON RxStr.ParentStreamBlock == Sb.Handle")
q_xcat = str("SELECT Name || '/' || Sb.FixedFrameLength " +
"FROM RxEotStreamResults As RxStr " +
"JOIN StreamBlock AS Sb " +
"ON RxStr.ParentStreamBlock == Sb.Handle")
min_jitter_data = get_data_from_query(db_list, q_minjitter)
avg_jitter_data = get_data_from_query(db_list, q_avgjitter)
max_jitter_data = get_data_from_query(db_list, q_maxjitter)
min_latency_data = get_data_from_query(db_list, q_minlatency)
avg_latency_data = get_data_from_query(db_list, q_avglatency)
max_latency_data = get_data_from_query(db_list, q_maxlatency)
pktloss_data = get_data_from_query(db_list, q_pktloss)
ooopkt_data = get_data_from_query(db_list, q_ooopkt)
latepkt_data = get_data_from_query(db_list, q_latepkt)
xcat_data = get_data_from_query(db_list, q_xcat)
base_template['series'][0]['data'] = min_jitter_data
base_template['series'][1]['data'] = avg_jitter_data
base_template['series'][2]['data'] = max_jitter_data
base_template['series'][3]['data'] = min_latency_data
base_template['series'][4]['data'] = avg_latency_data
base_template['series'][5]['data'] = max_latency_data
base_template['series'][6]['data'] = pktloss_data
base_template['series'][7]['data'] = ooopkt_data
base_template['series'][8]['data'] = latepkt_data
base_template['xAxis']['categories'] = xcat_data
result_data = init_chart_data_dict("GROUP_1")
pdg.submit_provider_data(result_data)
return ""
else:
# case 3: sequencer stopped on error
logger.LogInfo("Calling stop test with error.")
seq_status = sequencer.Get('Status')
pdg.submit_sequencer_execution_error(seq_status)
ResultInterface.stop_test()
except Exception, e:
stack_trace = traceback.format_exc()
logger.LogError(stack_trace)
pdg.submit_command_execution_error('EndOfTestCommand',
str(e),
stack_trace)
ResultInterface.stop_test()
exit_state = False
except:
stack_trace = traceback.format_exc()
logger.LogError(stack_trace)
pdg.submit_command_execution_error('EndOfTestCommand',
pc.UNKNOWN_EXCEPTION_MESSAGE,
tack_trace)
ResultInterface.stop_test()
exit_state = False
clean_up()
return exit_state
def reset():
return True
def run(ApplyVerdictToSummary, DynamicResultViewName, OperationType,
ResultCount, MinResultCount, MaxResultCount, ReportGroup, DisplayName,
PassedVerdictExplanation, FailedVerdictExplanation):
logger = PLLogger.GetLogger('methodology')
global vdrvc_object
try:
drv = vdrvc_object
# subscribe or refresh
if drv_utils.subscribe(drv) is False:
drv_utils.refresh(drv)
# get verdict and text
verdict_data = pu.get_comparision_verdict_with_text(OperationType,
drv.Get('ResultCount'),
ResultCount,
0,
0,
'result count')
# generate drill down data
prq = drv.GetObject('PresentationResultQuery')
col_names = prq.GetCollection('SelectProperties')
col_display_names = drv_utils.get_column_display_names(drv, col_names)
active_groupby = drv_utils.get_active_groupby(drv)
active_view_data = drv_utils.get_drilldown_data(drv,
active_groupby,
col_names,
col_display_names,
False)
group_order_list = drv_utils.get_export_groupby_ordered(col_names, False)
viewdata = []
for groupbyKey in reversed(group_order_list):
if active_groupby == groupbyKey:
viewdata.append(active_view_data)
else:
viewdata.append(drv_utils.get_drilldown_data(drv,
groupbyKey,
col_names,
col_display_names,
True))
drilldown_data = drv_utils.get_formatted_drilldown_data(viewdata)
provider_data = p.get_table_drv_drilldown_data(DynamicResultViewName,
verdict_data[pc.VERDICT],
verdict_data[pc.VERDICT_TEXT],
ApplyVerdictToSummary,
drilldown_data,
ReportGroup,
DisplayName,
PassedVerdictExplanation,
FailedVerdictExplanation)
p.submit_provider_data(provider_data)
# revert drv config changes
drv_utils.set_groupby(drv, active_groupby)
drv_utils.refresh(drv)
except Exception, e:
stack_trace = traceback.format_exc()
logger.LogError(stack_trace)
p.submit_command_execution_error(DisplayName,
str(e),
stack_trace)
return False
DisplayName,
PassedVerdictExplanation,
FailedVerdictExplanation)
p.submit_provider_data(provider_data)
# revert drv config changes
drv_utils.set_groupby(drv, active_groupby)
drv_utils.refresh(drv)
except Exception, e:
stack_trace = traceback.format_exc()
logger.LogError(stack_trace)
p.submit_command_execution_error(DisplayName,
str(e),
stack_trace)
return False
except:
stack_trace = traceback.format_exc()
logger.LogError(stack_trace)
p.submit_command_execution_error(DisplayName,
pc.UNKNOWN_EXCEPTION_MESSAGE,
stack_trace)
return False
return True
def reset():
global vdrvc_object
vdrvc_object = None
return True
def CreateChart(tagname, b, params):
plLogger = PLLogger.GetLogger("Methodology")
plLogger.LogDebug("Running custom CreateChart script...")
plLogger.LogDebug(" tagname : " + str(tagname))
db_list = get_dbs(True, False)
sb_info = get_active_streamblock_info(db_list)
logger.debug(" number of selected streams: " + str(len(sb_info)))
q_stream = get_streamblock_query()
q_maxjitter = (
str(
"SELECT ROUND(MaxJitter*1e-3,3) FROM RxEotStreamResults As RxStr "
+ "JOIN StreamBlock AS Sb "
+ "ON RxStr.ParentStreamBlock == Sb.Handle"
)
+ str(q_stream)
+ str(" WHERE IsExpectedPort = 1")
)
q_maxlatency = (
str(
"SELECT ROUND(MaxLatency*1e-3,3) FROM RxEotStreamResults As RxStr "
+ "JOIN StreamBlock AS Sb "
+ "ON RxStr.ParentStreamBlock == Sb.Handle"
)
+ str(q_stream)
+ str(" WHERE IsExpectedPort = 1")
)
q_pktloss = (
str(
"SELECT TxRes.FrameCount - RxRes.FrameCount "
+ "As 'Packet Loss' From RxEotStreamResults As RxRes "
+ "JOIN TxEotStreamResults As TxRes "
+ "JOIN Streamblock As Sb "
+ "ON RxRes.ParentStreamBlock = TxRes.ParentStreamblock "
+ "AND TxRes.ParentStreamblock = Sb.Handle"
)
+ str(q_stream)
+ str(" WHERE IsExpectedPort = 1")
)
q_ooopkt = (
str(
"SELECT OutSeqFrameCount FROM RxEotStreamResults As RxStr "
+ "JOIN StreamBlock AS Sb "
+ "ON RxStr.ParentStreamBlock == Sb.Handle"
)
+ str(q_stream)
+ str(" WHERE IsExpectedPort = 1")
)
q_latepkt = (
str(
"SELECT LateFrameCount FROM RxEotStreamResults As RxStr "
+ "JOIN StreamBlock AS Sb "
+ "ON RxStr.ParentStreamBlock == Sb.Handle"
)
+ str(q_stream)
+ str(" WHERE IsExpectedPort = 1")
)
q_duppkt = (
str(
"SELECT DuplicateFrameCount FROM RxEotStreamResults As RxStr "
+ "JOIN StreamBlock AS Sb "
+ "ON RxStr.ParentStreamBlock == Sb.Handle"
)
+ str(q_stream)
+ str(" WHERE IsExpectedPort = 1")
)
max_jitter_data = get_data_from_query(db_list, q_maxjitter)
max_latency_data = get_data_from_query(db_list, q_maxlatency)
pktloss_data = get_data_from_query(db_list, q_pktloss)
ooopkt_data = get_data_from_query(db_list, q_ooopkt)
latepkt_data = get_data_from_query(db_list, q_latepkt)
duppkt_data = get_data_from_query(db_list, q_duppkt)
xcat_data = [x + 1 for x in range(len(db_list))]
# jitter
get_per_stream_time_from_db(sb_info, max_jitter_data, "Jitter (ms)", xcat_data)
result_jitter = init_chart_data_dict("GROUP_1", time_template)
pdg.submit_provider_data(result_jitter)
# latency
get_per_stream_time_from_db(sb_info, max_latency_data, "Latency (ms)", xcat_data)
result_latency = init_chart_data_dict("GROUP_1", time_template)
pdg.submit_provider_data(result_latency)
# packet loss
get_per_stream_packet_from_db(sb_info, pktloss_data, "Packet Loss", xcat_data)
result_loss = init_chart_data_dict("GROUP_1", packet_template)
pdg.submit_provider_data(result_loss)
# ooo packet
get_per_stream_packet_from_db(sb_info, ooopkt_data, "Out of Order Packet", xcat_data)
result_ooo = init_chart_data_dict("GROUP_1", packet_template)
pdg.submit_provider_data(result_ooo)
# late packet
get_per_stream_packet_from_db(sb_info, latepkt_data, "Late Packet", xcat_data)
result_late = init_chart_data_dict("GROUP_1", packet_template)
pdg.submit_provider_data(result_late)
# duplicated packet
get_per_stream_packet_from_db(sb_info, duppkt_data, "Duplicated Packet", xcat_data)
result_dup = init_chart_data_dict("GROUP_1", packet_template)
pdg.submit_provider_data(result_dup)
return ""
