Unify IXIA/Trex test cases results

List of changes:
 - Unified naming of all counters reported by IXIA/Trex
 - Removed not valid counters reported by IXIA
 - Added per interface stats reported by Trex
 - Fixed latency calculation for Trex tg

JIRA: YARDSTICK-1592

Change-Id: Ia3d450058f884579f4d331772a8cf6de22146ac3
Signed-off-by: Serhiy Pshyk <serhiyx.pshyk@intel.com>

7 files changed, 301 insertions, 328 deletions

diff --git a/yardstick/network_services/libs/ixia_libs/ixnet/ixnet_api.py b/yardstick/network_services/libs/ixia_libs/ixnet/ixnet_api.py
index ebef7fd9a..89a855480 100644
--- a/yardstick/network_services/libs/ixia_libs/ixnet/ixnet_api.py
+++ b/yardstick/network_services/libs/ixia_libs/ixnet/ixnet_api.py
@@ -94,12 +94,6 @@ class IxNextgen(object):  # pragma: no cover
         "port_name": 'Port Name',
         "Frames_Tx": 'Frames Tx.',
         "Valid_Frames_Rx": 'Valid Frames Rx.',
-        "Frames_Tx_Rate": 'Frames Tx. Rate',
-        "Valid_Frames_Rx_Rate": 'Valid Frames Rx. Rate',
-        "Tx_Rate_Kbps": 'Tx. Rate (Kbps)',
-        "Rx_Rate_Kbps": 'Rx. Rate (Kbps)',
-        "Tx_Rate_Mbps": 'Tx. Rate (Mbps)',
-        "Rx_Rate_Mbps": 'Rx. Rate (Mbps)',
         "Bytes_Tx": 'Bytes Tx.',
         "Bytes_Rx": 'Bytes Rx.'
     }
diff --git a/yardstick/network_services/traffic_profile/ixia_rfc2544.py b/yardstick/network_services/traffic_profile/ixia_rfc2544.py
index 5a9c06aba..ca45b500d 100644
--- a/yardstick/network_services/traffic_profile/ixia_rfc2544.py
+++ b/yardstick/network_services/traffic_profile/ixia_rfc2544.py
@@ -195,13 +195,13 @@ class IXIARFC2544Profile(trex_traffic_profile.TrexProfile):
         num_ifaces = len(samples)
         duration = self.config.duration
         in_packets_sum = sum(
-            [samples[iface]['in_packets'] for iface in samples])
+            [samples[iface]['InPackets'] for iface in samples])
         out_packets_sum = sum(
-            [samples[iface]['out_packets'] for iface in samples])
+            [samples[iface]['OutPackets'] for iface in samples])
         in_bytes_sum = sum(
-            [samples[iface]['in_bytes'] for iface in samples])
+            [samples[iface]['InBytes'] for iface in samples])
         out_bytes_sum = sum(
-            [samples[iface]['out_bytes'] for iface in samples])
+            [samples[iface]['OutBytes'] for iface in samples])
         rx_throughput = round(float(in_packets_sum) / duration, 3)
         tx_throughput = round(float(out_packets_sum) / duration, 3)
         # Rx throughput in Bps
@@ -243,15 +243,10 @@ class IXIARFC2544Profile(trex_traffic_profile.TrexProfile):
                   "completed=%s", tolerance, precision, drop_percent,
                   completed)
 
-        latency_ns_avg = float(
-            sum([samples[iface]['Store-Forward_Avg_latency_ns']
-            for iface in samples])) / num_ifaces
-        latency_ns_min = float(
-            sum([samples[iface]['Store-Forward_Min_latency_ns']
-            for iface in samples])) / num_ifaces
-        latency_ns_max = float(
-            sum([samples[iface]['Store-Forward_Max_latency_ns']
-            for iface in samples])) / num_ifaces
+        latency_ns_avg = float(sum(
+            [samples[iface]['LatencyAvg'] for iface in samples])) / num_ifaces
+        latency_ns_min = min([samples[iface]['LatencyMin'] for iface in samples])
+        latency_ns_max = max([samples[iface]['LatencyMax'] for iface in samples])
 
         samples['Status'] = self.STATUS_FAIL
         if round(drop_percent, precision) <= tolerance:
@@ -262,9 +257,9 @@ class IXIARFC2544Profile(trex_traffic_profile.TrexProfile):
         samples['TxThroughputBps'] = tx_throughput_bps
         samples['RxThroughputBps'] = rx_throughput_bps
         samples['DropPercentage'] = drop_percent
-        samples['latency_ns_avg'] = latency_ns_avg
-        samples['latency_ns_min'] = latency_ns_min
-        samples['latency_ns_max'] = latency_ns_max
+        samples['LatencyAvg'] = latency_ns_avg
+        samples['LatencyMin'] = latency_ns_min
+        samples['LatencyMax'] = latency_ns_max
         samples['Rate'] = last_rate
         samples['PktSize'] = self._get_framesize()
         samples['Iteration'] = self.iteration
@@ -315,10 +310,10 @@ class IXIARFC2544PppoeScenarioProfile(IXIARFC2544Profile):
         drop_percent = 100
         for prio_id in stats:
             prio_flow = stats[prio_id]
-            sum_packet_drop = abs(prio_flow['out_packets'] - prio_flow['in_packets'])
+            sum_packet_drop = abs(prio_flow['OutPackets'] - prio_flow['InPackets'])
             try:
                 drop_percent = round(
-                    (sum_packet_drop / float(prio_flow['out_packets'])) * 100,
+                    (sum_packet_drop / float(prio_flow['OutPackets'])) * 100,
                     self.DROP_PERCENT_ROUND)
             except ZeroDivisionError:
                 LOG.info('No traffic is flowing')
@@ -327,10 +322,10 @@ class IXIARFC2544PppoeScenarioProfile(IXIARFC2544Profile):
 
     def _get_summary_pppoe_subs_counters(self, samples):
         result = {}
-        keys = ['sessions_up',
-                'sessions_down',
-                'sessions_not_started',
-                'sessions_total']
+        keys = ['SessionsUp',
+                'SessionsDown',
+                'SessionsNotStarted',
+                'SessionsTotal']
         for key in keys:
             result[key] = \
                 sum([samples[port][key] for port in samples
@@ -348,13 +343,13 @@ class IXIARFC2544PppoeScenarioProfile(IXIARFC2544Profile):
         priority_stats = self._get_prio_flows_drop_percentage(priority_stats)
         summary_subs_stats = self._get_summary_pppoe_subs_counters(samples)
         in_packets_sum = sum(
-            [samples[iface]['in_packets'] for iface in samples])
+            [samples[iface]['InPackets'] for iface in samples])
         out_packets_sum = sum(
-            [samples[iface]['out_packets'] for iface in samples])
+            [samples[iface]['OutPackets'] for iface in samples])
         in_bytes_sum = sum(
-            [samples[iface]['in_bytes'] for iface in samples])
+            [samples[iface]['InBytes'] for iface in samples])
         out_bytes_sum = sum(
-            [samples[iface]['out_bytes'] for iface in samples])
+            [samples[iface]['OutBytes'] for iface in samples])
         rx_throughput = round(float(in_packets_sum) / duration, 3)
         tx_throughput = round(float(out_packets_sum) / duration, 3)
         # Rx throughput in Bps
@@ -370,25 +365,20 @@ class IXIARFC2544PppoeScenarioProfile(IXIARFC2544Profile):
         except ZeroDivisionError:
             LOG.info('No traffic is flowing')
 
-        latency_ns_avg = float(
-            sum([samples[iface]['Store-Forward_Avg_latency_ns']
-                 for iface in samples])) / num_ifaces
-        latency_ns_min = float(
-            sum([samples[iface]['Store-Forward_Min_latency_ns']
-                 for iface in samples])) / num_ifaces
-        latency_ns_max = float(
-            sum([samples[iface]['Store-Forward_Max_latency_ns']
-                 for iface in samples])) / num_ifaces
+        latency_ns_avg = float(sum(
+            [samples[iface]['LatencyAvg'] for iface in samples])) / num_ifaces
+        latency_ns_min = min([samples[iface]['LatencyMin'] for iface in samples])
+        latency_ns_max = max([samples[iface]['LatencyMax'] for iface in samples])
 
         samples['TxThroughput'] = tx_throughput
         samples['RxThroughput'] = rx_throughput
         samples['TxThroughputBps'] = tx_throughput_bps
         samples['RxThroughputBps'] = rx_throughput_bps
         samples['DropPercentage'] = sum_drop_percent
-        samples['latency_ns_avg'] = latency_ns_avg
-        samples['latency_ns_min'] = latency_ns_min
-        samples['latency_ns_max'] = latency_ns_max
-        samples['priority'] = priority_stats
+        samples['LatencyAvg'] = latency_ns_avg
+        samples['LatencyMin'] = latency_ns_min
+        samples['LatencyMax'] = latency_ns_max
+        samples['Priority'] = priority_stats
         samples['Rate'] = last_rate
         samples['PktSize'] = self._get_framesize()
         samples['Iteration'] = self.iteration
@@ -397,7 +387,7 @@ class IXIARFC2544PppoeScenarioProfile(IXIARFC2544Profile):
         if tc_rfc2544_opts:
             priority = tc_rfc2544_opts.get('priority')
             if priority:
-                drop_percent = samples['priority'][priority]['DropPercentage']
+                drop_percent = samples['Priority'][priority]['DropPercentage']
             else:
                 drop_percent = sum_drop_percent
         else:
diff --git a/yardstick/network_services/traffic_profile/rfc2544.py b/yardstick/network_services/traffic_profile/rfc2544.py
index b12fa9360..aaa491b75 100644
--- a/yardstick/network_services/traffic_profile/rfc2544.py
+++ b/yardstick/network_services/traffic_profile/rfc2544.py
@@ -82,7 +82,6 @@ class RFC2544Profile(trex_traffic_profile.TrexProfile):
         self.rate = self.config.frame_rate
         self.max_rate = self.config.frame_rate
         self.min_rate = 0
-        self.drop_percent_max = 0
 
     def register_generator(self, generator):
         self.generator = generator
@@ -275,7 +274,7 @@ class RFC2544Profile(trex_traffic_profile.TrexProfile):
         return streams
 
     def get_drop_percentage(self, samples, tol_low, tol_high,
-                            correlated_traffic, resolution):
+                            correlated_traffic, resolution): # pylint: disable=unused-argument
         """Calculate the drop percentage and run the traffic"""
         completed = False
         status = self.STATUS_FAIL
@@ -321,26 +320,43 @@ class RFC2544Profile(trex_traffic_profile.TrexProfile):
         LOG.debug("rate=%s, next_rate=%s, resolution=%s, completed=%s",
                   last_rate, self.rate, resolution, completed)
 
-        throughput = rx_rate_fps * 2 if correlated_traffic else rx_rate_fps
-
-        if drop_percent > self.drop_percent_max:
-            self.drop_percent_max = drop_percent
-
-        latency = {port_num: value['latency']
-                   for port_num, value in samples[-1].items()}
-
-        output = {
-            'TxThroughput': tx_rate_fps,
-            'RxThroughput': rx_rate_fps,
-            'RxThroughputBps': round(float(in_bytes) / time_diff, 3),
-            'TxThroughputBps': round(float(out_bytes) / time_diff, 3),
-            'CurrentDropPercentage': drop_percent,
-            'Throughput': throughput,
-            'DropPercentage': self.drop_percent_max,
-            'Rate': last_rate,
-            'Latency': latency,
-            'PktSize': self._get_framesize(),
-            'Iteration': self.iteration,
-            'Status': status
-        }
+        ports = samples[-1].keys()
+        num_ports = len(ports)
+
+        output = {}
+        for port in ports:
+            output[port] = {}
+            first = samples[0][port]
+            last = samples[-1][port]
+            output[port]['InPackets'] = last['in_packets'] - first['in_packets']
+            output[port]['OutPackets'] = last['out_packets'] - first['out_packets']
+            output[port]['InBytes'] = last['in_bytes'] - first['in_bytes']
+            output[port]['OutBytes'] = last['out_bytes'] - first['out_bytes']
+            if self.config.enable_latency:
+                output[port]['LatencyAvg'] = float(sum(
+                    [last['latency'][id]['average'] for id in
+                     last['latency']]) * 1000) / len(last['latency'])
+                output[port]['LatencyMin'] = min(
+                    [last['latency'][id]['total_min'] for id in
+                     last['latency']]) * 1000
+                output[port]['LatencyMax'] = max(
+                    [last['latency'][id]['total_max'] for id in
+                     last['latency']]) * 1000
+
+        output['TxThroughput'] = tx_rate_fps
+        output['RxThroughput'] = rx_rate_fps
+        output['RxThroughputBps'] = round(float(in_bytes) / time_diff, 3)
+        output['TxThroughputBps'] = round(float(out_bytes) / time_diff, 3)
+        output['DropPercentage'] = drop_percent
+        output['Rate'] = last_rate
+        output['PktSize'] = self._get_framesize()
+        output['Iteration'] = self.iteration
+        output['Status'] = status
+
+        if self.config.enable_latency:
+            output['LatencyAvg'] = float(
+                sum([output[port]['LatencyAvg'] for port in ports])) / num_ports
+            output['LatencyMin'] = min([output[port]['LatencyMin'] for port in ports])
+            output['LatencyMax'] = max([output[port]['LatencyMax'] for port in ports])
+
         return completed, output
diff --git a/yardstick/network_services/vnf_generic/vnf/tg_rfc2544_ixia.py b/yardstick/network_services/vnf_generic/vnf/tg_rfc2544_ixia.py
index 5d64a8cba..80812876d 100644
--- a/yardstick/network_services/vnf_generic/vnf/tg_rfc2544_ixia.py
+++ b/yardstick/network_services/vnf_generic/vnf/tg_rfc2544_ixia.py
@@ -80,21 +80,17 @@ class IxiaBasicScenario(object):
                 min_latency = stats['Store-Forward_Min_latency_ns'][port_num]
                 max_latency = stats['Store-Forward_Max_latency_ns'][port_num]
                 samples[port_name] = {
-                    'rx_throughput_kps': float(stats['Rx_Rate_Kbps'][port_num]),
-                    'tx_throughput_kps': float(stats['Tx_Rate_Kbps'][port_num]),
-                    'rx_throughput_mbps': float(stats['Rx_Rate_Mbps'][port_num]),
-                    'tx_throughput_mbps': float(stats['Tx_Rate_Mbps'][port_num]),
                     'RxThroughputBps': float(stats['Bytes_Rx'][port_num]) / duration,
                     'TxThroughputBps': float(stats['Bytes_Tx'][port_num]) / duration,
-                    'in_packets': int(stats['Valid_Frames_Rx'][port_num]),
-                    'out_packets': int(stats['Frames_Tx'][port_num]),
-                    'in_bytes': int(stats['Bytes_Rx'][port_num]),
-                    'out_bytes': int(stats['Bytes_Tx'][port_num]),
+                    'InPackets': int(stats['Valid_Frames_Rx'][port_num]),
+                    'OutPackets': int(stats['Frames_Tx'][port_num]),
+                    'InBytes': int(stats['Bytes_Rx'][port_num]),
+                    'OutBytes': int(stats['Bytes_Tx'][port_num]),
                     'RxThroughput': float(stats['Valid_Frames_Rx'][port_num]) / duration,
                     'TxThroughput': float(stats['Frames_Tx'][port_num]) / duration,
-                    'Store-Forward_Avg_latency_ns': utils.safe_cast(avg_latency, int, 0),
-                    'Store-Forward_Min_latency_ns': utils.safe_cast(min_latency, int, 0),
-                    'Store-Forward_Max_latency_ns': utils.safe_cast(max_latency, int, 0)
+                    'LatencyAvg': utils.safe_cast(avg_latency, int, 0),
+                    'LatencyMin': utils.safe_cast(min_latency, int, 0),
+                    'LatencyMax': utils.safe_cast(max_latency, int, 0)
                 }
             except IndexError:
                 pass
@@ -524,22 +520,22 @@ class IxiaPppoeClientScenario(object):
             avg_latency_ns = sum(
                 [int(flow['Store-Forward_Avg_latency_ns']) for flow in samples
                  if flow['IP_Priority'] == priority]) / prio_flows_num
-            min_latency_ns = sum(
+            min_latency_ns = min(
                 [int(flow['Store-Forward_Min_latency_ns']) for flow in samples
-                 if flow['IP_Priority'] == priority]) / prio_flows_num
-            max_latency_ns = sum(
+                 if flow['IP_Priority'] == priority])
+            max_latency_ns = max(
                 [int(flow['Store-Forward_Max_latency_ns']) for flow in samples
-                 if flow['IP_Priority'] == priority]) / prio_flows_num
+                 if flow['IP_Priority'] == priority])
             tx_throughput = float(tx_frames) / duration
             rx_throughput = float(rx_frames) / duration
             results[priority] = {
-                'in_packets': rx_frames,
-                'out_packets': tx_frames,
+                'InPackets': rx_frames,
+                'OutPackets': tx_frames,
                 'RxThroughput': round(rx_throughput, 3),
                 'TxThroughput': round(tx_throughput, 3),
-                'avg_latency_ns': utils.safe_cast(avg_latency_ns, int, 0),
-                'min_latency_ns': utils.safe_cast(min_latency_ns, int, 0),
-                'max_latency_ns': utils.safe_cast(max_latency_ns, int, 0)
+                'LatencyAvg': utils.safe_cast(avg_latency_ns, int, 0),
+                'LatencyMin': utils.safe_cast(min_latency_ns, int, 0),
+                'LatencyMax': utils.safe_cast(max_latency_ns, int, 0)
             }
         return results
 
@@ -600,38 +596,34 @@ class IxiaPppoeClientScenario(object):
                         flows_stats, flow, 'Store-Forward_Avg_latency_ns'))
                         for flow in port_flow_map[port_num]]) / len(port_flow_map[port_num])
                 min_latency = \
-                    sum([float(self.get_flow_id_data(
+                    min([float(self.get_flow_id_data(
                         flows_stats, flow, 'Store-Forward_Min_latency_ns'))
-                        for flow in port_flow_map[port_num]]) / len(port_flow_map[port_num])
+                        for flow in port_flow_map[port_num]])
                 max_latency = \
-                    sum([float(self.get_flow_id_data(
+                    max([float(self.get_flow_id_data(
                         flows_stats, flow, 'Store-Forward_Max_latency_ns'))
-                        for flow in port_flow_map[port_num]]) / len(port_flow_map[port_num])
+                        for flow in port_flow_map[port_num]])
 
                 samples[port_name] = {
-                    'rx_throughput_kps': float(ports_stats[port_num]['Rx_Rate_Kbps']),
-                    'tx_throughput_kps': float(ports_stats[port_num]['Tx_Rate_Kbps']),
-                    'rx_throughput_mbps': float(ports_stats[port_num]['Rx_Rate_Mbps']),
-                    'tx_throughput_mbps': float(ports_stats[port_num]['Tx_Rate_Mbps']),
                     'RxThroughputBps': float(ports_stats[port_num]['Bytes_Rx']) / duration,
                     'TxThroughputBps': float(ports_stats[port_num]['Bytes_Tx']) / duration,
-                    'in_packets': int(ports_stats[port_num]['Valid_Frames_Rx']),
-                    'out_packets': int(ports_stats[port_num]['Frames_Tx']),
-                    'in_bytes': int(ports_stats[port_num]['Bytes_Rx']),
-                    'out_bytes': int(ports_stats[port_num]['Bytes_Tx']),
+                    'InPackets': int(ports_stats[port_num]['Valid_Frames_Rx']),
+                    'OutPackets': int(ports_stats[port_num]['Frames_Tx']),
+                    'InBytes': int(ports_stats[port_num]['Bytes_Rx']),
+                    'OutBytes': int(ports_stats[port_num]['Bytes_Tx']),
                     'RxThroughput': float(ports_stats[port_num]['Valid_Frames_Rx']) / duration,
                     'TxThroughput': float(ports_stats[port_num]['Frames_Tx']) / duration,
-                    'Store-Forward_Avg_latency_ns': utils.safe_cast(avg_latency, int, 0),
-                    'Store-Forward_Min_latency_ns': utils.safe_cast(min_latency, int, 0),
-                    'Store-Forward_Max_latency_ns': utils.safe_cast(max_latency, int, 0)
+                    'LatencyAvg': utils.safe_cast(avg_latency, int, 0),
+                    'LatencyMin': utils.safe_cast(min_latency, int, 0),
+                    'LatencyMax': utils.safe_cast(max_latency, int, 0)
                 }
 
                 if port_subs_stats:
                     samples[port_name].update(
-                        {'sessions_up': int(port_subs_stats[0]['Sessions_Up']),
-                         'sessions_down': int(port_subs_stats[0]['Sessions_Down']),
-                         'sessions_not_started': int(port_subs_stats[0]['Sessions_Not_Started']),
-                         'sessions_total': int(port_subs_stats[0]['Sessions_Total'])}
+                        {'SessionsUp': int(port_subs_stats[0]['Sessions_Up']),
+                         'SessionsDown': int(port_subs_stats[0]['Sessions_Down']),
+                         'SessionsNotStarted': int(port_subs_stats[0]['Sessions_Not_Started']),
+                         'SessionsTotal': int(port_subs_stats[0]['Sessions_Total'])}
                     )
 
             except IndexError:
diff --git a/yardstick/tests/unit/network_services/traffic_profile/test_ixia_rfc2544.py b/yardstick/tests/unit/network_services/traffic_profile/test_ixia_rfc2544.py
index 426d6b21b..ddd1828ae 100644
--- a/yardstick/tests/unit/network_services/traffic_profile/test_ixia_rfc2544.py
+++ b/yardstick/tests/unit/network_services/traffic_profile/test_ixia_rfc2544.py
@@ -627,17 +627,17 @@ class TestIXIARFC2544Profile(unittest.TestCase):
 
     def test_get_drop_percentage_completed(self):
         samples = {'iface_name_1':
-                       {'in_packets': 1000, 'out_packets': 1000,
-                        'in_bytes': 64000, 'out_bytes': 64000,
-                        'Store-Forward_Avg_latency_ns': 20,
-                        'Store-Forward_Min_latency_ns': 15,
-                        'Store-Forward_Max_latency_ns': 25},
+                       {'InPackets': 1000, 'OutPackets': 1000,
+                        'InBytes': 64000, 'OutBytes': 64000,
+                        'LatencyAvg': 20,
+                        'LatencyMin': 15,
+                        'LatencyMax': 25},
                    'iface_name_2':
-                       {'in_packets': 1005, 'out_packets': 1007,
-                        'in_bytes': 64320, 'out_bytes': 64448,
-                        'Store-Forward_Avg_latency_ns': 23,
-                        'Store-Forward_Min_latency_ns': 13,
-                        'Store-Forward_Max_latency_ns': 28}
+                       {'InPackets': 1005, 'OutPackets': 1007,
+                        'InBytes': 64320, 'OutBytes': 64448,
+                        'LatencyAvg': 23,
+                        'LatencyMin': 13,
+                        'LatencyMax': 28}
                    }
         rfc2544_profile = ixia_rfc2544.IXIARFC2544Profile(self.TRAFFIC_PROFILE)
         rfc2544_profile.rate = 100.0
@@ -649,25 +649,25 @@ class TestIXIARFC2544Profile(unittest.TestCase):
         self.assertEqual(66.9, samples['TxThroughput'])
         self.assertEqual(66.833, samples['RxThroughput'])
         self.assertEqual(0.099651, samples['DropPercentage'])
-        self.assertEqual(21.5, samples['latency_ns_avg'])
-        self.assertEqual(14.0, samples['latency_ns_min'])
-        self.assertEqual(26.5, samples['latency_ns_max'])
+        self.assertEqual(21.5, samples['LatencyAvg'])
+        self.assertEqual(13.0, samples['LatencyMin'])
+        self.assertEqual(28.0, samples['LatencyMax'])
         self.assertEqual(100.0, samples['Rate'])
         self.assertEqual('64B', samples['PktSize'])
 
     def test_get_drop_percentage_over_drop_percentage(self):
         samples = {'iface_name_1':
-                       {'in_packets': 1000, 'out_packets': 1000,
-                        'in_bytes': 64000, 'out_bytes': 64000,
-                        'Store-Forward_Avg_latency_ns': 20,
-                        'Store-Forward_Min_latency_ns': 15,
-                        'Store-Forward_Max_latency_ns': 25},
+                       {'InPackets': 1000, 'OutPackets': 1000,
+                        'InBytes': 64000, 'OutBytes': 64000,
+                        'LatencyAvg': 20,
+                        'LatencyMin': 15,
+                        'LatencyMax': 25},
                    'iface_name_2':
-                       {'in_packets': 1005, 'out_packets': 1007,
-                        'in_bytes': 64320, 'out_bytes': 64448,
-                        'Store-Forward_Avg_latency_ns': 20,
-                        'Store-Forward_Min_latency_ns': 15,
-                        'Store-Forward_Max_latency_ns': 25}
+                       {'InPackets': 1005, 'OutPackets': 1007,
+                        'InBytes': 64320, 'OutBytes': 64448,
+                        'LatencyAvg': 20,
+                        'LatencyMin': 15,
+                        'LatencyMax': 25}
                    }
         rfc2544_profile = ixia_rfc2544.IXIARFC2544Profile(self.TRAFFIC_PROFILE)
         rfc2544_profile.rate = 1000
@@ -682,17 +682,17 @@ class TestIXIARFC2544Profile(unittest.TestCase):
 
     def test_get_drop_percentage_under_drop_percentage(self):
         samples = {'iface_name_1':
-                       {'in_packets': 1000, 'out_packets': 1000,
-                        'in_bytes': 64000, 'out_bytes': 64000,
-                        'Store-Forward_Avg_latency_ns': 20,
-                        'Store-Forward_Min_latency_ns': 15,
-                        'Store-Forward_Max_latency_ns': 25},
+                       {'InPackets': 1000, 'OutPackets': 1000,
+                        'InBytes': 64000, 'OutBytes': 64000,
+                        'LatencyAvg': 20,
+                        'LatencyMin': 15,
+                        'LatencyMax': 25},
                    'iface_name_2':
-                       {'in_packets': 1005, 'out_packets': 1007,
-                        'in_bytes': 64320, 'out_bytes': 64448,
-                        'Store-Forward_Avg_latency_ns': 20,
-                        'Store-Forward_Min_latency_ns': 15,
-                        'Store-Forward_Max_latency_ns': 25}
+                       {'InPackets': 1005, 'OutPackets': 1007,
+                        'InBytes': 64320, 'OutBytes': 64448,
+                        'LatencyAvg': 20,
+                        'LatencyMin': 15,
+                        'LatencyMax': 25}
                    }
         rfc2544_profile = ixia_rfc2544.IXIARFC2544Profile(self.TRAFFIC_PROFILE)
         rfc2544_profile.rate = 1000
@@ -708,17 +708,17 @@ class TestIXIARFC2544Profile(unittest.TestCase):
     @mock.patch.object(ixia_rfc2544.LOG, 'info')
     def test_get_drop_percentage_not_flow(self, *args):
         samples = {'iface_name_1':
-                       {'in_packets': 1000, 'out_packets': 0,
-                        'in_bytes': 64000, 'out_bytes': 0,
-                        'Store-Forward_Avg_latency_ns': 20,
-                        'Store-Forward_Min_latency_ns': 15,
-                        'Store-Forward_Max_latency_ns': 25},
+                       {'InPackets': 1000, 'OutPackets': 0,
+                        'InBytes': 64000, 'OutBytes': 0,
+                        'LatencyAvg': 20,
+                        'LatencyMin': 15,
+                        'LatencyMax': 25},
                    'iface_name_2':
-                       {'in_packets': 1005, 'out_packets': 0,
-                        'in_bytes': 64320, 'out_bytes': 0,
-                        'Store-Forward_Avg_latency_ns': 20,
-                        'Store-Forward_Min_latency_ns': 15,
-                        'Store-Forward_Max_latency_ns': 25}
+                       {'InPackets': 1005, 'OutPackets': 0,
+                        'InBytes': 64320, 'OutBytes': 0,
+                        'LatencyAvg': 20,
+                        'LatencyMin': 15,
+                        'LatencyMax': 25}
                    }
         rfc2544_profile = ixia_rfc2544.IXIARFC2544Profile(self.TRAFFIC_PROFILE)
         rfc2544_profile.rate = 1000
@@ -733,17 +733,17 @@ class TestIXIARFC2544Profile(unittest.TestCase):
 
     def test_get_drop_percentage_first_run(self):
         samples = {'iface_name_1':
-                       {'in_packets': 1000, 'out_packets': 1000,
-                        'in_bytes': 64000, 'out_bytes': 64000,
-                        'Store-Forward_Avg_latency_ns': 20,
-                        'Store-Forward_Min_latency_ns': 15,
-                        'Store-Forward_Max_latency_ns': 25},
+                       {'InPackets': 1000, 'OutPackets': 1000,
+                        'InBytes': 64000, 'OutBytes': 64000,
+                        'LatencyAvg': 20,
+                        'LatencyMin': 15,
+                        'LatencyMax': 25},
                    'iface_name_2':
-                       {'in_packets': 1005, 'out_packets': 1007,
-                        'in_bytes': 64320, 'out_bytes': 64448,
-                        'Store-Forward_Avg_latency_ns': 20,
-                        'Store-Forward_Min_latency_ns': 15,
-                        'Store-Forward_Max_latency_ns': 25}
+                       {'InPackets': 1005, 'OutPackets': 1007,
+                        'InBytes': 64320, 'OutBytes': 64448,
+                        'LatencyAvg': 20,
+                        'LatencyMin': 15,
+                        'LatencyMax': 25}
                    }
         rfc2544_profile = ixia_rfc2544.IXIARFC2544Profile(self.TRAFFIC_PROFILE)
         rfc2544_profile._get_next_rate = mock.Mock(return_value=50.0)
@@ -759,17 +759,17 @@ class TestIXIARFC2544Profile(unittest.TestCase):
         rfc2544_profile = ixia_rfc2544.IXIARFC2544Profile(self.TRAFFIC_PROFILE)
         rfc2544_profile._get_next_rate = mock.Mock(return_value=0.1)
         samples = {'iface_name_1':
-                       {'in_packets': 1000, 'out_packets': 1000,
-                        'in_bytes': 64000, 'out_bytes': 64000,
-                        'Store-Forward_Avg_latency_ns': 20,
-                        'Store-Forward_Min_latency_ns': 15,
-                        'Store-Forward_Max_latency_ns': 25},
+                       {'InPackets': 1000, 'OutPackets': 1000,
+                        'InBytes': 64000, 'OutBytes': 64000,
+                        'LatencyAvg': 20,
+                        'LatencyMin': 15,
+                        'LatencyMax': 25},
                    'iface_name_2':
-                       {'in_packets': 1005, 'out_packets': 1007,
-                        'in_bytes': 64320, 'out_bytes': 64448,
-                        'Store-Forward_Avg_latency_ns': 20,
-                        'Store-Forward_Min_latency_ns': 15,
-                        'Store-Forward_Max_latency_ns': 25}
+                       {'InPackets': 1005, 'OutPackets': 1007,
+                        'InBytes': 64320, 'OutBytes': 64448,
+                        'LatencyAvg': 20,
+                        'LatencyMin': 15,
+                        'LatencyMax': 25}
                    }
         rfc2544_profile.rate = 0.19
         completed, _ = rfc2544_profile.get_drop_percentage(
@@ -777,17 +777,17 @@ class TestIXIARFC2544Profile(unittest.TestCase):
         self.assertTrue(completed)
 
         samples = {'iface_name_1':
-                       {'in_packets': 1000, 'out_packets': 1000,
-                        'in_bytes': 64000, 'out_bytes': 64000,
-                        'Store-Forward_Avg_latency_ns': 20,
-                        'Store-Forward_Min_latency_ns': 15,
-                        'Store-Forward_Max_latency_ns': 25},
+                       {'InPackets': 1000, 'OutPackets': 1000,
+                        'InBytes': 64000, 'OutBytes': 64000,
+                        'LatencyAvg': 20,
+                        'LatencyMin': 15,
+                        'LatencyMax': 25},
                    'iface_name_2':
-                       {'in_packets': 1005, 'out_packets': 1007,
-                        'in_bytes': 64320, 'out_bytes': 64448,
-                        'Store-Forward_Avg_latency_ns': 20,
-                        'Store-Forward_Min_latency_ns': 15,
-                        'Store-Forward_Max_latency_ns': 25}
+                       {'InPackets': 1005, 'OutPackets': 1007,
+                        'InBytes': 64320, 'OutBytes': 64448,
+                        'LatencyAvg': 20,
+                        'LatencyMin': 15,
+                        'LatencyMax': 25}
                    }
         rfc2544_profile.rate = 0.5
         completed, _ = rfc2544_profile.get_drop_percentage(
@@ -852,8 +852,8 @@ class TestIXIARFC2544PppoeScenarioProfile(unittest.TestCase):
 
         input_stats = {
             '0': {
-                'in_packets': 50,
-                'out_packets': 100,
+                'InPackets': 50,
+                'OutPackets': 100,
                 'Store-Forward_Avg_latency_ns': 10,
                 'Store-Forward_Min_latency_ns': 10,
                 'Store-Forward_Max_latency_ns': 10}}
@@ -865,8 +865,8 @@ class TestIXIARFC2544PppoeScenarioProfile(unittest.TestCase):
     def test__get_prio_flows_drop_percentage_traffic_not_flowing(self):
         input_stats = {
             '0': {
-                'in_packets': 0,
-                'out_packets': 0,
+                'InPackets': 0,
+                'OutPackets': 0,
                 'Store-Forward_Avg_latency_ns': 0,
                 'Store-Forward_Min_latency_ns': 0,
                 'Store-Forward_Max_latency_ns': 0}}
@@ -878,24 +878,24 @@ class TestIXIARFC2544PppoeScenarioProfile(unittest.TestCase):
     def test__get_summary_pppoe_subs_counters(self):
         input_stats = {
             'xe0': {
-                'out_packets': 100,
-                'sessions_up': 4,
-                'sessions_down': 0,
-                'sessions_not_started': 0,
-                'sessions_total': 4},
+                'OutPackets': 100,
+                'SessionsUp': 4,
+                'SessionsDown': 0,
+                'SessionsNotStarted': 0,
+                'SessionsTotal': 4},
             'xe1': {
-                'out_packets': 100,
-                'sessions_up': 4,
-                'sessions_down': 0,
-                'sessions_not_started': 0,
-                'sessions_total': 4}
+                'OutPackets': 100,
+                'SessionsUp': 4,
+                'SessionsDown': 0,
+                'SessionsNotStarted': 0,
+                'SessionsTotal': 4}
         }
 
         expected_stats = {
-            'sessions_up': 8,
-            'sessions_down': 0,
-            'sessions_not_started': 0,
-            'sessions_total': 8
+            'SessionsUp': 8,
+            'SessionsDown': 0,
+            'SessionsNotStarted': 0,
+            'SessionsTotal': 8
         }
 
         res = self.ixia_tp._get_summary_pppoe_subs_counters(input_stats)
@@ -910,23 +910,23 @@ class TestIXIARFC2544PppoeScenarioProfile(unittest.TestCase):
         samples = {
             'priority_stats': {
                 '0': {
-                    'in_packets': 100,
-                    'out_packets': 100,
-                    'in_bytes': 6400,
-                    'out_bytes': 6400,
-                    'Store-Forward_Avg_latency_ns': 10,
-                    'Store-Forward_Min_latency_ns': 10,
-                    'Store-Forward_Max_latency_ns': 10}},
+                    'InPackets': 100,
+                    'OutPackets': 100,
+                    'InBytes': 6400,
+                    'OutBytes': 6400,
+                    'LatencyAvg': 10,
+                    'LatencyMin': 10,
+                    'LatencyMax': 10}},
             'xe0': {
-                'in_packets': 100,
-                'out_packets': 100,
-                'in_bytes': 6400,
-                'out_bytes': 6400,
-                'Store-Forward_Avg_latency_ns': 10,
-                'Store-Forward_Min_latency_ns': 10,
-                'Store-Forward_Max_latency_ns': 10}}
-
-        mock_get_pppoe_subs.return_value = {'sessions_up': 1}
+                'InPackets': 100,
+                'OutPackets': 100,
+                'InBytes': 6400,
+                'OutBytes': 6400,
+                'LatencyAvg': 10,
+                'LatencyMin': 10,
+                'LatencyMax': 10}}
+
+        mock_get_pppoe_subs.return_value = {'SessionsUp': 1}
         mock_sum_prio_drop_rate.return_value = {'0': {'DropPercentage': 0.0}}
 
         self.ixia_tp._get_framesize = mock.Mock(return_value='64B')
@@ -934,8 +934,8 @@ class TestIXIARFC2544PppoeScenarioProfile(unittest.TestCase):
             samples, tol_min=0.0, tolerance=0.0001, precision=0,
             resolution=0.1, first_run=True)
         self.assertIsNotNone(res.get('DropPercentage'))
-        self.assertIsNotNone(res.get('priority'))
-        self.assertIsNotNone(res.get('sessions_up'))
+        self.assertIsNotNone(res.get('Priority'))
+        self.assertIsNotNone(res.get('SessionsUp'))
         self.assertEqual(res['DropPercentage'], 0.0)
         self.assertEqual(res['Rate'], 100.0)
         self.assertEqual(res['PktSize'], '64B')
@@ -952,31 +952,31 @@ class TestIXIARFC2544PppoeScenarioProfile(unittest.TestCase):
         samples = {
             'priority_stats': {
                 '0': {
-                    'in_packets': 90,
-                    'out_packets': 100,
-                    'in_bytes': 5760,
-                    'out_bytes': 6400,
-                    'Store-Forward_Avg_latency_ns': 10,
-                    'Store-Forward_Min_latency_ns': 10,
-                    'Store-Forward_Max_latency_ns': 10}},
+                    'InPackets': 90,
+                    'OutPackets': 100,
+                    'InBytes': 5760,
+                    'OutBytes': 6400,
+                    'LatencyAvg': 10,
+                    'LatencyMin': 10,
+                    'LatencyMax': 10}},
             'xe0': {
-                'in_packets': 90,
-                'out_packets': 100,
-                'in_bytes': 5760,
-                'out_bytes': 6400,
-                'Store-Forward_Avg_latency_ns': 10,
-                'Store-Forward_Min_latency_ns': 10,
-                'Store-Forward_Max_latency_ns': 10}}
-
-        mock_get_pppoe_subs.return_value = {'sessions_up': 1}
+                'InPackets': 90,
+                'OutPackets': 100,
+                'InBytes': 5760,
+                'OutBytes': 6400,
+                'LatencyAvg': 10,
+                'LatencyMin': 10,
+                'LatencyMax': 10}}
+
+        mock_get_pppoe_subs.return_value = {'SessionsUp': 1}
         mock_sum_prio_drop_rate.return_value = {'0': {'DropPercentage': 0.0}}
 
         status, res = self.ixia_tp.get_drop_percentage(
             samples, tol_min=0.0, tolerance=0.0001, precision=0,
             resolution=0.1, first_run=True)
         self.assertIsNotNone(res.get('DropPercentage'))
-        self.assertIsNotNone(res.get('priority'))
-        self.assertIsNotNone(res.get('sessions_up'))
+        self.assertIsNotNone(res.get('Priority'))
+        self.assertIsNotNone(res.get('SessionsUp'))
         self.assertEqual(res['DropPercentage'], 10.0)
         self.assertFalse(status)
         mock_sum_prio_drop_rate.assert_called_once()
@@ -991,24 +991,24 @@ class TestIXIARFC2544PppoeScenarioProfile(unittest.TestCase):
         samples = {
             'priority_stats': {
                 '0': {
-                    'in_packets': 100,
-                    'out_packets': 100,
-                    'in_bytes': 6400,
-                    'out_bytes': 6400,
-                    'Store-Forward_Avg_latency_ns': 10,
-                    'Store-Forward_Min_latency_ns': 10,
-                    'Store-Forward_Max_latency_ns': 10}},
+                    'InPackets': 100,
+                    'OutPackets': 100,
+                    'InBytes': 6400,
+                    'OutBytes': 6400,
+                    'LatencyAvg': 10,
+                    'LatencyMin': 10,
+                    'LatencyMax': 10}},
             'xe0': {
-                'in_packets': 90,
-                'out_packets': 100,
-                'in_bytes': 5760,
-                'out_bytes': 6400,
-                'Store-Forward_Avg_latency_ns': 10,
-                'Store-Forward_Min_latency_ns': 10,
-                'Store-Forward_Max_latency_ns': 10
+                'InPackets': 90,
+                'OutPackets': 100,
+                'InBytes': 5760,
+                'OutBytes': 6400,
+                'LatencyAvg': 10,
+                'LatencyMin': 10,
+                'LatencyMax': 10
         }}
 
-        mock_get_pppoe_subs.return_value = {'sessions_up': 1}
+        mock_get_pppoe_subs.return_value = {'SessionsUp': 1}
         mock_sum_prio_drop_rate.return_value = {'0': {'DropPercentage': 0.0}}
 
         tc_rfc2544_opts = {'priority': '0',
@@ -1017,8 +1017,8 @@ class TestIXIARFC2544PppoeScenarioProfile(unittest.TestCase):
             samples, tol_min=15.0000, tolerance=15.0001, precision=0,
             resolution=0.1, first_run=True, tc_rfc2544_opts=tc_rfc2544_opts)
         self.assertIsNotNone(res.get('DropPercentage'))
-        self.assertIsNotNone(res.get('priority'))
-        self.assertIsNotNone(res.get('sessions_up'))
+        self.assertIsNotNone(res.get('Priority'))
+        self.assertIsNotNone(res.get('SessionsUp'))
         self.assertTrue(status)
         mock_sum_prio_drop_rate.assert_called_once()
         mock_get_pppoe_subs.assert_called_once()
diff --git a/yardstick/tests/unit/network_services/traffic_profile/test_rfc2544.py b/yardstick/tests/unit/network_services/traffic_profile/test_rfc2544.py
index 6d3558c7e..febcfe5da 100644
--- a/yardstick/tests/unit/network_services/traffic_profile/test_rfc2544.py
+++ b/yardstick/tests/unit/network_services/traffic_profile/test_rfc2544.py
@@ -255,31 +255,23 @@ class TestRFC2544Profile(base.BaseUnitTestCase):
         mock_get_framesize.return_value = '64B'
 
         samples = [
-            {'xe1': {'tx_throughput_fps': 110,
-                     'rx_throughput_fps': 101,
-                     'out_packets': 2100,
+            {'xe1': {'out_packets': 2100,
                      'in_packets': 2010,
                      'out_bytes': 134400,
                      'in_bytes': 128640,
                      'timestamp': datetime.datetime(2000, 1, 1, 1, 1, 1, 1)},
-             'xe2': {'tx_throughput_fps': 210,
-                     'rx_throughput_fps': 201,
-                     'out_packets': 4100,
+             'xe2': {'out_packets': 4100,
                      'in_packets': 4010,
                      'out_bytes': 262400,
                      'in_bytes': 256640,
                      'timestamp': datetime.datetime(2000, 1, 1, 1, 1, 1, 1)}},
-            {'xe1': {'tx_throughput_fps': 156,
-                     'rx_throughput_fps': 108,
-                     'out_packets': 2110,
+            {'xe1': {'out_packets': 2110,
                      'in_packets': 2040,
                      'out_bytes': 135040,
                      'in_bytes': 130560,
                      'latency': 'Latency1',
                      'timestamp': datetime.datetime(2000, 1, 1, 1, 1, 1, 31)},
-             'xe2': {'tx_throughput_fps': 253,
-                     'rx_throughput_fps': 215,
-                     'out_packets': 4150,
+             'xe2': {'out_packets': 4150,
                      'in_packets': 4010,
                      'out_bytes': 265600,
                      'in_bytes': 256640,
@@ -288,15 +280,20 @@ class TestRFC2544Profile(base.BaseUnitTestCase):
         ]
         completed, output = rfc2544_profile.get_drop_percentage(
             samples, 0, 0, False, 0.1)
-        expected = {'DropPercentage': 50.0,
-                    'Latency': {'xe1': 'Latency1', 'xe2': 'Latency2'},
+        expected = {'xe1': {'OutPackets': 10,
+                            'InPackets': 30,
+                            'OutBytes': 640,
+                            'InBytes': 1920},
+                    'xe2': {'OutPackets': 50,
+                            'InPackets': 0,
+                            'OutBytes': 3200,
+                            'InBytes': 0},
+                    'DropPercentage': 50.0,
                     'RxThroughput': 1000000.0,
                     'TxThroughput': 2000000.0,
                     'RxThroughputBps': 64000000.0,
                     'TxThroughputBps': 128000000.0,
-                    'CurrentDropPercentage': 50.0,
                     'Rate': 100.0,
-                    'Throughput': 1000000.0,
                     'Iteration': 1,
                     'PktSize': '64B',
                     'Status': 'Failure'}
diff --git a/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_rfc2544_ixia.py b/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_rfc2544_ixia.py
index 51a379cee..c3f3e5f67 100644
--- a/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_rfc2544_ixia.py
+++ b/yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_rfc2544_ixia.py
@@ -556,37 +556,29 @@ class TestIxiaBasicScenario(unittest.TestCase):
     def test_generate_samples(self, mock_get_stats):
 
         expected_samples = {'xe0': {
-                                'in_packets': 150,
-                                'out_packets': 150,
-                                'in_bytes': 9600,
-                                'out_bytes': 9600,
-                                'rx_throughput_mbps': 0.0,
-                                'rx_throughput_kps': 0.0,
+                                'InPackets': 150,
+                                'OutPackets': 150,
+                                'InBytes': 9600,
+                                'OutBytes': 9600,
                                 'RxThroughput': 5.0,
                                 'TxThroughput': 5.0,
                                 'RxThroughputBps': 320.0,
                                 'TxThroughputBps': 320.0,
-                                'tx_throughput_mbps': 0.0,
-                                'tx_throughput_kps': 0.0,
-                                'Store-Forward_Max_latency_ns': 100,
-                                'Store-Forward_Min_latency_ns': 100,
-                                'Store-Forward_Avg_latency_ns': 100},
+                                'LatencyMax': 100,
+                                'LatencyMin': 100,
+                                'LatencyAvg': 100},
                             'xe1': {
-                                'in_packets': 150,
-                                'out_packets': 150,
-                                'in_bytes': 9600,
-                                'out_bytes': 9600,
-                                'rx_throughput_mbps': 0.0,
-                                'rx_throughput_kps': 0.0,
+                                'InPackets': 150,
+                                'OutPackets': 150,
+                                'InBytes': 9600,
+                                'OutBytes': 9600,
                                 'RxThroughput': 5.0,
                                 'TxThroughput': 5.0,
                                 'RxThroughputBps': 320.0,
                                 'TxThroughputBps': 320.0,
-                                'tx_throughput_mbps': 0.0,
-                                'tx_throughput_kps': 0.0,
-                                'Store-Forward_Max_latency_ns': 200,
-                                'Store-Forward_Min_latency_ns': 200,
-                                'Store-Forward_Avg_latency_ns': 200}}
+                                'LatencyMax': 200,
+                                'LatencyMin': 200,
+                                'LatencyAvg': 200}}
 
         res_helper = mock.Mock()
         res_helper.vnfd_helper.find_interface_by_port.side_effect = \
@@ -1211,58 +1203,50 @@ class TestIxiaPppoeClientScenario(unittest.TestCase):
 
         prio_flows_stats = {
             '0': {
-                'in_packets': 6000,
-                'out_packets': 6000,
+                'InPackets': 6000,
+                'OutPackets': 6000,
                 'RxThroughput': 200.0,
                 'TxThroughput': 200.0,
-                'avg_latency_ns': 2,
-                'max_latency_ns': 2,
-                'min_latency_ns': 2
+                'LatencyAvg': 2,
+                'LatencyMax': 2,
+                'LatencyMin': 2
             }
         }
 
         expected_result = {'priority_stats': {
             '0': {'RxThroughput': 200.0,
                   'TxThroughput': 200.0,
-                  'avg_latency_ns': 2,
-                  'max_latency_ns': 2,
-                  'min_latency_ns': 2,
-                  'in_packets': 6000,
-                  'out_packets': 6000}},
+                  'LatencyAvg': 2,
+                  'LatencyMax': 2,
+                  'LatencyMin': 2,
+                  'InPackets': 6000,
+                  'OutPackets': 6000}},
             'xe0': {'RxThroughput': 100.0,
-                    'Store-Forward_Avg_latency_ns': 2,
-                    'Store-Forward_Max_latency_ns': 2,
-                    'Store-Forward_Min_latency_ns': 2,
+                    'LatencyAvg': 2,
+                    'LatencyMax': 2,
+                    'LatencyMin': 2,
                     'TxThroughput': 100.0,
-                    'in_packets': 3000,
-                    'out_packets': 3000,
-                    'in_bytes': 192000,
-                    'out_bytes': 192000,
+                    'InPackets': 3000,
+                    'OutPackets': 3000,
+                    'InBytes': 192000,
+                    'OutBytes': 192000,
                     'RxThroughputBps': 6400.0,
                     'TxThroughputBps': 6400.0,
-                    'rx_throughput_kps': 0.0,
-                    'rx_throughput_mbps': 0.0,
-                    'sessions_down': 0,
-                    'sessions_not_started': 0,
-                    'sessions_total': 1,
-                    'sessions_up': 1,
-                    'tx_throughput_kps': 0.0,
-                    'tx_throughput_mbps': 0.0},
+                    'SessionsDown': 0,
+                    'SessionsNotStarted': 0,
+                    'SessionsTotal': 1,
+                    'SessionsUp': 1},
             'xe1': {'RxThroughput': 100.0,
-                    'Store-Forward_Avg_latency_ns': 2,
-                    'Store-Forward_Max_latency_ns': 2,
-                    'Store-Forward_Min_latency_ns': 2,
+                    'LatencyAvg': 2,
+                    'LatencyMax': 2,
+                    'LatencyMin': 2,
                     'TxThroughput': 100.0,
-                    'in_packets': 3000,
-                    'out_packets': 3000,
-                    'in_bytes': 192000,
-                    'out_bytes': 192000,
+                    'InPackets': 3000,
+                    'OutPackets': 3000,
+                    'InBytes': 192000,
+                    'OutBytes': 192000,
                     'RxThroughputBps': 6400.0,
-                    'TxThroughputBps': 6400.0,
-                    'rx_throughput_kps': 0.0,
-                    'rx_throughput_mbps': 0.0,
-                    'tx_throughput_kps': 0.0,
-                    'tx_throughput_mbps': 0.0}}
+                    'TxThroughputBps': 6400.0}}
 
         mock_get_stats.return_value = ixia_stats
         mock_prio_flow_statistics.return_value = prio_flows_stats