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

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