vstf/vstf/controller/spirent/common/result_analysis.py

   1 ##############################################################################
   2 # Copyright (c) 2015 Huawei Technologies Co.,Ltd and others.
   3 #
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 ##############################################################################
   9
  10
  11 import re
  12
  13
  14 def getResultColumn(data_dict):
  15     column_string = data_dict['Columns']
  16     return column_string.strip('{}').split()
  17
  18
  19 def getResult(data_dict):
  20     result_string = data_dict['Output']
  21     result_array = result_string.split('} {')
  22     result = []
  23     for line in result_array:
  24         result.append(line.split())
  25     return result
  26
  27
  28 def restrucData(data_string):
  29     try:
  30         data_dict = {}
  31         p = re.compile('-Columns.*-Output')
  32         data_dict['Columns'] = p.findall(data_string)[0].strip('-Columns {} -Output')
  33         p = re.compile('-Output.*-State')
  34         data_dict['Output'] = p.findall(data_string)[0].strip('-Output {} -State')
  35         if data_dict['Columns'] is not None or data_dict['Output'] is not None:
  36             return False, None
  37         return True, data_dict
  38     except:
  39         print("[ERROR]Find the column name or the output result failed.")
  40
  41
  42 def framelossData(column, perfdata):
  43     column_name_dict = {
  44         'TrialNumber': 0,
  45         'Id': 1,
  46         'FrameSize': 3,
  47         'TxFrameCount': 9,
  48         'RxFrameCount': 10,
  49         'PercentLoss(%s)': 12,
  50         'MinimumLatency(us)': 17,
  51         'MaximumLatency(us)': 18,
  52         'AverageLatency(us)': 19,
  53         'MinimumJitter(us)': 20,
  54         'MaximumJitter(us)': 21,
  55         'AverageJitter(us)': 22,
  56     }
  57     # get the column array
  58     column_array = [
  59         column[column_name_dict['FrameSize']],
  60         'ForwardingRate(Mpps)',
  61         column[column_name_dict['TxFrameCount']],
  62         column[column_name_dict['RxFrameCount']],
  63         column[column_name_dict['PercentLoss(%s)']],
  64         column[column_name_dict['AverageLatency(us)']],
  65         column[column_name_dict['MinimumLatency(us)']],
  66         column[column_name_dict['MaximumLatency(us)']],
  67         column[column_name_dict['AverageJitter(us)']],
  68         column[column_name_dict['MinimumJitter(us)']],
  69         column[column_name_dict['MaximumJitter(us)']]
  70     ]
  71     data_array = []
  72     for line in perfdata:
  73         line_options = [
  74             #                             line[column_name_dict['TrialNumber']],
  75             #                             line[column_name_dict['Id']],
  76             line[column_name_dict['FrameSize']],
  77             str(float(line[column_name_dict['RxFrameCount']]) / 60 / 1000000),
  78             line[column_name_dict['TxFrameCount']],
  79             line[column_name_dict['RxFrameCount']],
  80             line[column_name_dict['PercentLoss(%s)']],
  81             line[column_name_dict['AverageLatency(us)']],
  82             line[column_name_dict['MinimumLatency(us)']],
  83             line[column_name_dict['MaximumLatency(us)']],
  84             line[column_name_dict['AverageJitter(us)']],
  85             line[column_name_dict['MinimumJitter(us)']],
  86             line[column_name_dict['MaximumJitter(us)']]
  87         ]
  88         data_array.append(line_options)
  89     return [column_array, data_array]
  90
  91
  92 class analysis(object):
  93     def __init__(self):
  94         pass
  95
  96     def analyseResult(self, suite, column, perfdata):
  97         """
  98         :type self: object
  99         """
 100         global data_array, column_array
 101         if suite == 'throughput':
 102             [column_array, data_array] = self.throughputData(column, perfdata)
 103         elif suite == 'frameloss':
 104             [column_array, data_array] = self.framelossData(column, perfdata)
 105         elif suite == 'latency':
 106             self.latencyData(column, perfdata)
 107         else:
 108             return None
 109         for line in data_array:
 110             print line
 111         return [column_array, data_array]
 112
 113     def throughputData(self, column, perfdata):
 114         column_name_dict = {
 115             'TrialNumber': 0,
 116             'Id': 1,
 117             'FrameSize': 3,
 118             'Load(%)': 6,
 119             'Result': 8,
 120             'TxFrameCount': 12,
 121             'RxFrameCount': 13,
 122             'ForwardingRate(mpps)': 17,
 123             'MinimumLatency(us)': 18,
 124             'MaximumLatency(us)': 19,
 125             'AverageLatency(us)': 20,
 126             'MinimumJitter(us)': 21,
 127             'MaximumJitter(us)': 22,
 128             'AverageJitter(us)': 23
 129         }
 130         column_array = {column[column_name_dict['FrameSize']],
 131                         column[column_name_dict['Load(%)']],
 132                         column[column_name_dict['Result']],
 133                         'ForwardingRate(mpps)',
 134                         column[column_name_dict['TxFrameCount']],
 135                         column[column_name_dict['RxFrameCount']],
 136                         column[column_name_dict['AverageLatency(us)']],
 137                         column[column_name_dict['MinimumLatency(us)']],
 138                         column[column_name_dict['MaximumLatency(us)']],
 139                         column[column_name_dict['AverageJitter(us)']],
 140                         column[column_name_dict['MinimumJitter(us)']],
 141                         column[column_name_dict['MaximumJitter(us)']]}
 142         data_array = []
 143         for line in perfdata:
 144             if line[column_name_dict['Result']] == 'Passed':
 145                 line_options = [
 146                     #                                 line[column_name_dict['TrialNumber']],
 147                     #                                 line[column_name_dict['Id']],
 148                     line[column_name_dict['FrameSize']],
 149                     line[column_name_dict['Load(%)']],
 150                     line[column_name_dict['Result']],
 151                     str(float(line[column_name_dict['ForwardingRate(mpps)']]) / 1000000),
 152                     line[column_name_dict['TxFrameCount']],
 153                     line[column_name_dict['RxFrameCount']],
 154                     line[column_name_dict['AverageLatency(us)']],
 155                     line[column_name_dict['MinimumLatency(us)']],
 156                     line[column_name_dict['MaximumLatency(us)']],
 157                     line[column_name_dict['AverageJitter(us)']],
 158                     line[column_name_dict['MinimumJitter(us)']],
 159                     line[column_name_dict['MaximumJitter(us)']]]
 160             else:
 161                 continue
 162             data_array.append(line_options)
 163         # delete the redundant test data
 164         delete_index = []
 165         new_data_array = []
 166         for ele in range(len(data_array) - 1):
 167             if data_array[ele][0] == data_array[ele + 1][0]:
 168                 delete_index.append(ele)
 169
 170         for num in len(data_array):
 171             if num not in delete_index:
 172                 new_data_array.append(data_array[num])
 173
 174         return column_array, new_data_array
 175
 176     def latencyData(self, column, perfdata):
 177         pass
 178
 179
 180 analysis_instance = analysis()