Trending: Fix Alerts

[csit.git] / resources / tools / presentation / input_data_parser.py

diff --git a/resources/tools/presentation/input_data_parser.py b/resources/tools/presentation/input_data_parser.py
index f2656d2..d23fa84 100644 (file)
--- a/resources/tools/presentation/input_data_parser.py
+++ b/resources/tools/presentation/input_data_parser.py
@@ -20,27 +20,28 @@
 """
 
 import re
 """
 
 import re

+import copy

 import resource
 import resource

-import pandas as pd

 import logging
 import logging

-import prettytable

 
 

-from robot.api import ExecutionResult, ResultVisitor
-from robot import errors

 from collections import OrderedDict
 from collections import OrderedDict

-from string import replace

 from os import remove
 from os import remove

-from os.path import join

 from datetime import datetime as dt
 from datetime import timedelta
 from json import loads
 from datetime import datetime as dt
 from datetime import timedelta
 from json import loads

-from jumpavg.AvgStdevMetadataFactory import AvgStdevMetadataFactory

 
 

+import prettytable
+import pandas as pd
+
+from robot.api import ExecutionResult, ResultVisitor
+from robot import errors
+
+from resources.libraries.python import jumpavg

 from input_data_files import download_and_unzip_data_file
 
 
 # Separator used in file names
 from input_data_files import download_and_unzip_data_file
 
 
 # Separator used in file names

-SEPARATOR = "__"
+SEPARATOR = u"__"

 
 
 class ExecutionChecker(ResultVisitor):
 
 
 class ExecutionChecker(ResultVisitor):


@@ -98,24 +99,28 @@ class ExecutionChecker(ResultVisitor):
                         "direction1": {
                             "min": float,
                             "avg": float,
                         "direction1": {
                             "min": float,
                             "avg": float,

-                            "max": float
+                            "max": float,
+                            "hdrh": str

                         },
                         "direction2": {
                             "min": float,
                             "avg": float,
                         },
                         "direction2": {
                             "min": float,
                             "avg": float,

-                            "max": float
+                            "max": float,
+                            "hdrh": str

                         }
                     },
                     "PDR": {
                         "direction1": {
                             "min": float,
                             "avg": float,
                         }
                     },
                     "PDR": {
                         "direction1": {
                             "min": float,
                             "avg": float,

-                            "max": float
+                            "max": float,
+                            "hdrh": str

                         },
                         "direction2": {
                             "min": float,
                             "avg": float,
                         },
                         "direction2": {
                             "min": float,
                             "avg": float,

-                            "max": float
+                            "max": float,
+                            "hdrh": str

                         }
                     }
                 }
                         }
                     }
                 }


@@ -143,64 +148,12 @@ class ExecutionChecker(ResultVisitor):
                 "type": "MRR" | "BMRR",
                 "status": "PASS" | "FAIL",
                 "result": {
                 "type": "MRR" | "BMRR",
                 "status": "PASS" | "FAIL",
                 "result": {

-                    "receive-rate": AvgStdevMetadata,
+                    "receive-rate": float,
+                    # Average of a list, computed using AvgStdevStats.
+                    # In CSIT-1180, replace with List[float].

                 }
             }
 
                 }
             }
 

-            # TODO: Remove when definitely no NDRPDRDISC tests are used:
-            # NDRPDRDISC tests:
-            "ID": {
-                "name": "Test name",
-                "parent": "Name of the parent of the test",
-                "doc": "Test documentation",
-                "msg": "Test message",
-                "tags": ["tag 1", "tag 2", "tag n"],
-                "type": "PDR" | "NDR",
-                "status": "PASS" | "FAIL",
-                "throughput": {  # Only type: "PDR" | "NDR"
-                    "value": int,
-                    "unit": "pps" | "bps" | "percentage"
-                },
-                "latency": {  # Only type: "PDR" | "NDR"
-                    "direction1": {
-                        "100": {
-                            "min": int,
-                            "avg": int,
-                            "max": int
-                        },
-                        "50": {  # Only for NDR
-                            "min": int,
-                            "avg": int,
-                            "max": int
-                        },
-                        "10": {  # Only for NDR
-                            "min": int,
-                            "avg": int,
-                            "max": int
-                        }
-                    },
-                    "direction2": {
-                        "100": {
-                            "min": int,
-                            "avg": int,
-                            "max": int
-                        },
-                        "50": {  # Only for NDR
-                            "min": int,
-                            "avg": int,
-                            "max": int
-                        },
-                        "10": {  # Only for NDR
-                            "min": int,
-                            "avg": int,
-                            "max": int
-                        }
-                    }
-                },
-                "lossTolerance": "lossTolerance",  # Only type: "PDR"
-                "conf-history": "DUT1 and DUT2 VAT History"
-                "show-run": "Show Run"
-            },

             "ID" {
                 # next test
             }
             "ID" {
                 # next test
             }


@@ -248,30 +201,14 @@ class ExecutionChecker(ResultVisitor):
     .. note:: ID is the lowercase full path to the test.
     """
 
     .. note:: ID is the lowercase full path to the test.
     """
 

-    # TODO: Remove when definitely no NDRPDRDISC tests are used:
-    REGEX_RATE = re.compile(r'^[\D\d]*FINAL_RATE:\s(\d+\.\d+)\s(\w+)')
-
-    REGEX_PLR_RATE = re.compile(r'PLRsearch lower bound::\s(\d+.\d+).*\n'
-                                r'PLRsearch upper bound::\s(\d+.\d+)')
+    REGEX_PLR_RATE = re.compile(r'PLRsearch lower bound::?\s(\d+.\d+).*\n'
+                                r'PLRsearch upper bound::?\s(\d+.\d+)')

 
     REGEX_NDRPDR_RATE = re.compile(r'NDR_LOWER:\s(\d+.\d+).*\n.*\n'
                                    r'NDR_UPPER:\s(\d+.\d+).*\n'
                                    r'PDR_LOWER:\s(\d+.\d+).*\n.*\n'
                                    r'PDR_UPPER:\s(\d+.\d+)')
 
 
     REGEX_NDRPDR_RATE = re.compile(r'NDR_LOWER:\s(\d+.\d+).*\n.*\n'
                                    r'NDR_UPPER:\s(\d+.\d+).*\n'
                                    r'PDR_LOWER:\s(\d+.\d+).*\n.*\n'
                                    r'PDR_UPPER:\s(\d+.\d+)')
 

-    # TODO: Remove when definitely no NDRPDRDISC tests are used:
-    REGEX_LAT_NDR = re.compile(r'^[\D\d]*'
-                               r'LAT_\d+%NDR:\s\[\'(-?\d+/-?\d+/-?\d+)\','
-                               r'\s\'(-?\d+/-?\d+/-?\d+)\'\]\s\n'
-                               r'LAT_\d+%NDR:\s\[\'(-?\d+/-?\d+/-?\d+)\','
-                               r'\s\'(-?\d+/-?\d+/-?\d+)\'\]\s\n'
-                               r'LAT_\d+%NDR:\s\[\'(-?\d+/-?\d+/-?\d+)\','
-                               r'\s\'(-?\d+/-?\d+/-?\d+)\'\]')
-
-    REGEX_LAT_PDR = re.compile(r'^[\D\d]*'
-                               r'LAT_\d+%PDR:\s\[\'(-?\d+/-?\d+/-?\d+)\','
-                               r'\s\'(-?\d+/-?\d+/-?\d+)\'\][\D\d]*')
-

     REGEX_NDRPDR_LAT = re.compile(r'LATENCY.*\[\'(.*)\', \'(.*)\'\]\s\n.*\n.*\n'
                                   r'LATENCY.*\[\'(.*)\', \'(.*)\'\]')
 
     REGEX_NDRPDR_LAT = re.compile(r'LATENCY.*\[\'(.*)\', \'(.*)\'\]\s\n.*\n.*\n'
                                   r'LATENCY.*\[\'(.*)\', \'(.*)\'\]')
 


@@ -281,9 +218,9 @@ class ExecutionChecker(ResultVisitor):
     REGEX_VERSION_VPP = re.compile(r"(return STDOUT Version:\s*|"
                                    r"VPP Version:\s*|VPP version:\s*)(.*)")
 
     REGEX_VERSION_VPP = re.compile(r"(return STDOUT Version:\s*|"
                                    r"VPP Version:\s*|VPP version:\s*)(.*)")
 

-    REGEX_VERSION_DPDK = re.compile(r"DPDK Version: (\d*.\d*)")
+    REGEX_VERSION_DPDK = re.compile(r"(DPDK version:\s*|DPDK Version:\s*)(.*)")

 
 

-    REGEX_TCP = re.compile(r'Total\s(rps|cps|throughput):\s([0-9]*).*$')
+    REGEX_TCP = re.compile(r'Total\s(rps|cps|throughput):\s(\d*).*$')

 
     REGEX_MRR = re.compile(r'MaxReceivedRate_Results\s\[pkts/(\d*)sec\]:\s'
                            r'tx\s(\d*),\srx\s(\d*)')
 
     REGEX_MRR = re.compile(r'MaxReceivedRate_Results\s\[pkts/(\d*)sec\]:\s'
                            r'tx\s(\d*),\srx\s(\d*)')


@@ -291,13 +228,18 @@ class ExecutionChecker(ResultVisitor):
     REGEX_BMRR = re.compile(r'Maximum Receive Rate trial results'
                             r' in packets per second: \[(.*)\]')
 
     REGEX_BMRR = re.compile(r'Maximum Receive Rate trial results'
                             r' in packets per second: \[(.*)\]')
 

+    REGEX_RECONF_LOSS = re.compile(r'Packets lost due to reconfig: (\d*)')
+    REGEX_RECONF_TIME = re.compile(r'Implied time lost: (\d*.[\de-]*)')
+

     REGEX_TC_TAG = re.compile(r'\d+[tT]\d+[cC]')
 
     REGEX_TC_NAME_OLD = re.compile(r'-\d+[tT]\d+[cC]-')
 
     REGEX_TC_NAME_NEW = re.compile(r'-\d+[cC]-')
 
     REGEX_TC_TAG = re.compile(r'\d+[tT]\d+[cC]')
 
     REGEX_TC_NAME_OLD = re.compile(r'-\d+[tT]\d+[cC]-')
 
     REGEX_TC_NAME_NEW = re.compile(r'-\d+[cC]-')
 

-    REGEX_TC_NUMBER = re.compile(r'tc[0-9]{2}-')
+    REGEX_TC_NUMBER = re.compile(r'tc\d{2}-')
+
+    REGEX_TC_PAPI_CLI = re.compile(r'.*\((\d+.\d+.\d+.\d+.) - (.*)\)')

 
     def __init__(self, metadata, mapping, ignore):
         """Initialisation.
 
     def __init__(self, metadata, mapping, ignore):
         """Initialisation.


@@ -330,10 +272,10 @@ class ExecutionChecker(ResultVisitor):
         # Ignore list
         self._ignore = ignore
 
         # Ignore list
         self._ignore = ignore
 

-        # Number of VAT History messages found:
+        # Number of PAPI History messages found:

         # 0 - no message
         # 0 - no message

-        # 1 - VAT History of DUT1
-        # 2 - VAT History of DUT2
+        # 1 - PAPI History of DUT1
+        # 2 - PAPI History of DUT2

         self._lookup_kw_nr = 0
         self._conf_history_lookup_nr = 0
 
         self._lookup_kw_nr = 0
         self._conf_history_lookup_nr = 0
 


@@ -344,29 +286,30 @@ class ExecutionChecker(ResultVisitor):
 
         # Test ID of currently processed test- the lowercase full path to the
         # test
 
         # Test ID of currently processed test- the lowercase full path to the
         # test

-        self._test_ID = None
+        self._test_id = None

 
         # The main data structure
         self._data = {
 
         # The main data structure
         self._data = {

-            "metadata": OrderedDict(),
-            "suites": OrderedDict(),
-            "tests": OrderedDict()
+            u"metadata": OrderedDict(),
+            u"suites": OrderedDict(),
+            u"tests": OrderedDict()

         }
 
         # Save the provided metadata
         for key, val in metadata.items():
         }
 
         # Save the provided metadata
         for key, val in metadata.items():

-            self._data["metadata"][key] = val
+            self._data[u"metadata"][key] = val

 
         # Dictionary defining the methods used to parse different types of
         # messages
         self.parse_msg = {
 
         # Dictionary defining the methods used to parse different types of
         # messages
         self.parse_msg = {

-            "timestamp": self._get_timestamp,
-            "vpp-version": self._get_vpp_version,
-            "dpdk-version": self._get_dpdk_version,
-            "teardown-vat-history": self._get_vat_history,
-            "teardown-papi-history": self._get_papi_history,
-            "test-show-runtime": self._get_show_run,
-            "testbed": self._get_testbed
+            u"timestamp": self._get_timestamp,
+            u"vpp-version": self._get_vpp_version,
+            u"dpdk-version": self._get_dpdk_version,
+            # TODO: Remove when not needed:
+            u"teardown-vat-history": self._get_vat_history,
+            u"teardown-papi-history": self._get_papi_history,
+            u"test-show-runtime": self._get_show_run,
+            u"testbed": self._get_testbed

         }
 
     @property
         }
 
     @property


@@ -387,15 +330,16 @@ class ExecutionChecker(ResultVisitor):
         :returns: Nothing.
         """
 
         :returns: Nothing.
         """
 

-        if msg.message.count("Setup of TG node"):
+        if msg.message.count(u"Setup of TG node") or \
+                msg.message.count(u"Setup of node TG host"):

             reg_tg_ip = re.compile(
             reg_tg_ip = re.compile(

-                r'Setup of TG node (\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}) done')
+                r'.*TG .* (\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}).*')

             try:
                 self._testbed = str(re.search(reg_tg_ip, msg.message).group(1))
             except (KeyError, ValueError, IndexError, AttributeError):
                 pass
             finally:
             try:
                 self._testbed = str(re.search(reg_tg_ip, msg.message).group(1))
             except (KeyError, ValueError, IndexError, AttributeError):
                 pass
             finally:

-                self._data["metadata"]["testbed"] = self._testbed
+                self._data[u"metadata"][u"testbed"] = self._testbed

                 self._msg_type = None
 
     def _get_vpp_version(self, msg):
                 self._msg_type = None
 
     def _get_vpp_version(self, msg):


@@ -406,12 +350,12 @@ class ExecutionChecker(ResultVisitor):
         :returns: Nothing.
         """
 
         :returns: Nothing.
         """
 

-        if msg.message.count("return STDOUT Version:") or \
-            msg.message.count("VPP Version:") or \
-            msg.message.count("VPP version:"):
+        if msg.message.count(u"return STDOUT Version:") or \
+            msg.message.count(u"VPP Version:") or \
+            msg.message.count(u"VPP version:"):

             self._version = str(re.search(self.REGEX_VERSION_VPP, msg.message).
                                 group(2))
             self._version = str(re.search(self.REGEX_VERSION_VPP, msg.message).
                                 group(2))

-            self._data["metadata"]["version"] = self._version
+            self._data[u"metadata"][u"version"] = self._version

             self._msg_type = None
 
     def _get_dpdk_version(self, msg):
             self._msg_type = None
 
     def _get_dpdk_version(self, msg):


@@ -422,11 +366,11 @@ class ExecutionChecker(ResultVisitor):
         :returns: Nothing.
         """
 
         :returns: Nothing.
         """
 

-        if msg.message.count("DPDK Version:"):
+        if msg.message.count(u"DPDK Version:"):

             try:
                 self._version = str(re.search(
             try:
                 self._version = str(re.search(

-                    self.REGEX_VERSION_DPDK, msg.message). group(1))
-                self._data["metadata"]["version"] = self._version
+                    self.REGEX_VERSION_DPDK, msg.message).group(2))
+                self._data[u"metadata"][u"version"] = self._version

             except IndexError:
                 pass
             finally:
             except IndexError:
                 pass
             finally:


@@ -441,30 +385,32 @@ class ExecutionChecker(ResultVisitor):
         """
 
         self._timestamp = msg.timestamp[:14]
         """
 
         self._timestamp = msg.timestamp[:14]

-        self._data["metadata"]["generated"] = self._timestamp
+        self._data[u"metadata"][u"generated"] = self._timestamp

         self._msg_type = None
 
     def _get_vat_history(self, msg):
         """Called when extraction of VAT command history is required.
 
         self._msg_type = None
 
     def _get_vat_history(self, msg):
         """Called when extraction of VAT command history is required.
 

+        TODO: Remove when not needed.
+

         :param msg: Message to process.
         :type msg: Message
         :returns: Nothing.
         """
         :param msg: Message to process.
         :type msg: Message
         :returns: Nothing.
         """

-        if msg.message.count("VAT command history:"):
+        if msg.message.count(u"VAT command history:"):

             self._conf_history_lookup_nr += 1
             if self._conf_history_lookup_nr == 1:
             self._conf_history_lookup_nr += 1
             if self._conf_history_lookup_nr == 1:

-                self._data["tests"][self._test_ID]["conf-history"] = str()
+                self._data[u"tests"][self._test_id][u"conf-history"] = str()

             else:
                 self._msg_type = None
             else:
                 self._msg_type = None

-            text = re.sub("[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3} "
-                          "VAT command history:", "", msg.message, count=1). \
-                replace("\n\n", "\n").replace('\n', ' |br| ').\
-                replace('\r', '').replace('"', "'")
+            text = re.sub(r"\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3} "
+                          r"VAT command history:", u"",
+                          msg.message, count=1).replace(u'\n', u' |br| ').\
+                replace(u'"', u"'")

 
 

-            self._data["tests"][self._test_ID]["conf-history"] += " |br| "
-            self._data["tests"][self._test_ID]["conf-history"] += \
-                "**DUT" + str(self._conf_history_lookup_nr) + ":** " + text
+            self._data[u"tests"][self._test_id][u"conf-history"] += (
+                f" |br| **DUT{str(self._conf_history_lookup_nr)}:** {text}"
+            )

 
     def _get_papi_history(self, msg):
         """Called when extraction of PAPI command history is required.
 
     def _get_papi_history(self, msg):
         """Called when extraction of PAPI command history is required.


@@ -473,20 +419,20 @@ class ExecutionChecker(ResultVisitor):
         :type msg: Message
         :returns: Nothing.
         """
         :type msg: Message
         :returns: Nothing.
         """

-        if msg.message.count("PAPI command history:"):
+        if msg.message.count(u"PAPI command history:"):

             self._conf_history_lookup_nr += 1
             if self._conf_history_lookup_nr == 1:
             self._conf_history_lookup_nr += 1
             if self._conf_history_lookup_nr == 1:

-                self._data["tests"][self._test_ID]["conf-history"] = str()
+                self._data[u"tests"][self._test_id][u"conf-history"] = str()

             else:
                 self._msg_type = None
             else:
                 self._msg_type = None

-            text = re.sub("[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3} "
-                          "PAPI command history:", "", msg.message, count=1). \
-                replace("\n\n", "\n").replace('\n', ' |br| ').\
-                replace('\r', '').replace('"', "'")
+            text = re.sub(r"\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3} "
+                          r"PAPI command history:", u"",
+                          msg.message, count=1).replace(u'\n', u' |br| ').\
+                replace(u'"', u"'")

 
 

-            self._data["tests"][self._test_ID]["conf-history"] += " |br| "
-            self._data["tests"][self._test_ID]["conf-history"] += \
-                "**DUT" + str(self._conf_history_lookup_nr) + ":** " + text
+            self._data[u"tests"][self._test_id][u"conf-history"] += (
+                f" |br| **DUT{str(self._conf_history_lookup_nr)}:** {text}"
+            )

 
     def _get_show_run(self, msg):
         """Called when extraction of VPP operational data (output of CLI command
 
     def _get_show_run(self, msg):
         """Called when extraction of VPP operational data (output of CLI command


@@ -496,105 +442,97 @@ class ExecutionChecker(ResultVisitor):
         :type msg: Message
         :returns: Nothing.
         """
         :type msg: Message
         :returns: Nothing.
         """

-        if msg.message.count("Runtime:"):
-            self._show_run_lookup_nr += 1
-            if self._lookup_kw_nr == 1 and self._show_run_lookup_nr == 1:
-                self._data["tests"][self._test_ID]["show-run"] = str()
-            if self._lookup_kw_nr > 1:
-                self._msg_type = None
-            if self._show_run_lookup_nr == 1:
-                message = str(msg.message).replace(' ', '').replace('\n', '').\
-                    replace("'", '"').replace('b"', '"').replace('u"', '"')[8:]
-                runtime = loads(message)
-                try:
-                    threads_nr = len(runtime[0]["clocks"])
-                except (IndexError, KeyError):
-                    return
-                tbl_hdr = ["Name", "Calls", "Vectors", "Suspends", "Clocks"]
-                table = [[tbl_hdr, ] for _ in range(threads_nr)]
-                for item in runtime:
-                    for idx in range(threads_nr):
-                        table[idx].append([
-                            item["name"],
-                            item["calls"][idx],
-                            item["vectors"][idx],
-                            item["suspends"][idx],
-                            item["clocks"][idx]
-                        ])
-                text = ""
-                for idx in range(threads_nr):
-                    text += "Thread {idx} ".format(idx=idx)
-                    text += "vpp_main\n" if idx == 0 else \
-                        "vpp_wk_{idx}\n".format(idx=idx-1)
-                    txt_table = None
-                    for row in table[idx]:
-                        if txt_table is None:
-                            txt_table = prettytable.PrettyTable(row)
-                        else:
-                            if any(row[1:]):
-                                txt_table.add_row(row)
-                    txt_table.align["Name"] = "l"
-                    txt_table.align["Calls"] = "r"
-                    txt_table.align["Vectors"] = "r"
-                    txt_table.align["Suspends"] = "r"
-                    txt_table.align["Clocks"] = "r"
-
-                    text += txt_table.get_html_string(sortby="Name") + '\n'
-
-                text = text.replace('\n', '').replace('\r', '')
-                try:
-                    self._data["tests"][self._test_ID]["show-run"] += " |br| "
-                    self._data["tests"][self._test_ID]["show-run"] += \
-                        "**DUT" + str(self._lookup_kw_nr) + ":** |br| " + text
-                except KeyError:
-                    pass
-
-    # TODO: Remove when definitely no NDRPDRDISC tests are used:
-    def _get_latency(self, msg, test_type):
-        """Get the latency data from the test message.
-
-        :param msg: Message to be parsed.
-        :param test_type: Type of the test - NDR or PDR.
-        :type msg: str
-        :type test_type: str
-        :returns: Latencies parsed from the message.
-        :rtype: dict
-        """

 
 

-        if test_type == "NDR":
-            groups = re.search(self.REGEX_LAT_NDR, msg)
-            groups_range = range(1, 7)
-        elif test_type == "PDR":
-            groups = re.search(self.REGEX_LAT_PDR, msg)
-            groups_range = range(1, 3)
-        else:
-            return {}
+        if u"show-run" not in self._data[u"tests"][self._test_id].keys():
+            self._data[u"tests"][self._test_id][u"show-run"] = str()

 
 

-        latencies = list()
-        for idx in groups_range:
+        if msg.message.count(u"stats runtime") or \
+                msg.message.count(u"Runtime"):

             try:
             try:

-                lat = [int(item) for item in str(groups.group(idx)).split('/')]
-            except (AttributeError, ValueError):
-                lat = [-1, -1, -1]
-            latencies.append(lat)
-
-        keys = ("min", "avg", "max")
-        latency = {
-            "direction1": {
-            },
-            "direction2": {
-            }
-        }
-
-        latency["direction1"]["100"] = dict(zip(keys, latencies[0]))
-        latency["direction2"]["100"] = dict(zip(keys, latencies[1]))
-        if test_type == "NDR":
-            latency["direction1"]["50"] = dict(zip(keys, latencies[2]))
-            latency["direction2"]["50"] = dict(zip(keys, latencies[3]))
-            latency["direction1"]["10"] = dict(zip(keys, latencies[4]))
-            latency["direction2"]["10"] = dict(zip(keys, latencies[5]))
-
-        return latency
+                host = str(re.search(self.REGEX_TC_PAPI_CLI, msg.message).
+                           group(1))
+            except (AttributeError, IndexError):
+                host = self._data[u"tests"][self._test_id][u"show-run"].\
+                           count(u"DUT:") + 1
+            try:
+                socket = str(re.search(self.REGEX_TC_PAPI_CLI, msg.message).
+                             group(2))
+                socket = f"/{socket}"
+            except (AttributeError, IndexError):
+                socket = u""
+            runtime = loads(
+                str(msg.message).
+                replace(u' ', u'').
+                replace(u'\n', u'').
+                replace(u"'", u'"').
+                replace(u'b"', u'"').
+                replace(u'u"', u'"').
+                split(u":", 1)[1]
+            )
+            try:
+                threads_nr = len(runtime[0][u"clocks"])
+            except (IndexError, KeyError):
+                return
+            tbl_hdr = [
+                u"Name",
+                u"Calls",
+                u"Vectors",
+                u"Suspends",
+                u"Clocks",
+                u"Vectors/Calls"
+            ]
+            table = [[tbl_hdr, ] for _ in range(threads_nr)]
+            for item in runtime:
+                for idx in range(threads_nr):
+                    name = format(item[u"name"])
+                    calls = format(item[u"calls"][idx])
+                    vectors = format(item[u"vectors"][idx])
+                    suspends = format(item[u"suspends"][idx])
+                    if item[u"vectors"][idx] > 0:
+                        clocks = format(
+                            item[u"clocks"][idx]/item[u"vectors"][idx], u".2e")
+                    elif item[u"calls"][idx] > 0:
+                        clocks = format(
+                            item[u"clocks"][idx]/item[u"calls"][idx], u".2e")
+                    elif item[u"suspends"][idx] > 0:
+                        clocks = format(
+                            item[u"clocks"][idx]/item[u"suspends"][idx], u".2e")
+                    else:
+                        clocks = 0
+                    if item[u"calls"][idx] > 0:
+                        vectors_call = format(
+                            item[u"vectors"][idx]/item[u"calls"][idx], u".2f")
+                    else:
+                        vectors_call = format(0, u".2f")
+                    if int(calls) + int(vectors) + int(suspends):
+                        table[idx].append([
+                            name, calls, vectors, suspends, clocks, vectors_call
+                        ])
+            text = ""
+            for idx in range(threads_nr):
+                text += f"Thread {idx} "
+                text += u"vpp_main\n" if idx == 0 else f"vpp_wk_{idx-1}\n"
+                txt_table = None
+                for row in table[idx]:
+                    if txt_table is None:
+                        txt_table = prettytable.PrettyTable(row)
+                    else:
+                        if any(row[1:]):
+                            txt_table.add_row(row)
+                txt_table.set_style(prettytable.MSWORD_FRIENDLY)
+                txt_table.align[u"Name"] = u"l"
+                txt_table.align[u"Calls"] = u"r"
+                txt_table.align[u"Vectors"] = u"r"
+                txt_table.align[u"Suspends"] = u"r"
+                txt_table.align[u"Clocks"] = u"r"
+                txt_table.align[u"Vectors/Calls"] = u"r"
+
+                text += txt_table.get_string(sortby=u"Name") + u'\n'
+            text = f" \n**DUT: {host}{socket}**\n{text}".\
+                replace(u'\n', u' |br| ').\
+                replace(u'\r', u'').\
+                replace(u'"', u"'")
+            self._data[u"tests"][self._test_id][u"show-run"] += text

 
     def _get_ndrpdr_throughput(self, msg):
         """Get NDR_LOWER, NDR_UPPER, PDR_LOWER and PDR_UPPER from the test
 
     def _get_ndrpdr_throughput(self, msg):
         """Get NDR_LOWER, NDR_UPPER, PDR_LOWER and PDR_UPPER from the test


@@ -607,19 +545,19 @@ class ExecutionChecker(ResultVisitor):
         """
 
         throughput = {
         """
 
         throughput = {

-            "NDR": {"LOWER": -1.0, "UPPER": -1.0},
-            "PDR": {"LOWER": -1.0, "UPPER": -1.0}
+            u"NDR": {u"LOWER": -1.0, u"UPPER": -1.0},
+            u"PDR": {u"LOWER": -1.0, u"UPPER": -1.0}

         }
         }

-        status = "FAIL"
+        status = u"FAIL"

         groups = re.search(self.REGEX_NDRPDR_RATE, msg)
 
         if groups is not None:
             try:
         groups = re.search(self.REGEX_NDRPDR_RATE, msg)
 
         if groups is not None:
             try:

-                throughput["NDR"]["LOWER"] = float(groups.group(1))
-                throughput["NDR"]["UPPER"] = float(groups.group(2))
-                throughput["PDR"]["LOWER"] = float(groups.group(3))
-                throughput["PDR"]["UPPER"] = float(groups.group(4))
-                status = "PASS"
+                throughput[u"NDR"][u"LOWER"] = float(groups.group(1))
+                throughput[u"NDR"][u"UPPER"] = float(groups.group(2))
+                throughput[u"PDR"][u"LOWER"] = float(groups.group(3))
+                throughput[u"PDR"][u"UPPER"] = float(groups.group(4))
+                status = u"PASS"

             except (IndexError, ValueError):
                 pass
 
             except (IndexError, ValueError):
                 pass
 


@@ -636,17 +574,17 @@ class ExecutionChecker(ResultVisitor):
         """
 
         throughput = {
         """
 
         throughput = {

-            "LOWER": -1.0,
-            "UPPER": -1.0
+            u"LOWER": -1.0,
+            u"UPPER": -1.0

         }
         }

-        status = "FAIL"
+        status = u"FAIL"

         groups = re.search(self.REGEX_PLR_RATE, msg)
 
         if groups is not None:
             try:
         groups = re.search(self.REGEX_PLR_RATE, msg)
 
         if groups is not None:
             try:

-                throughput["LOWER"] = float(groups.group(1))
-                throughput["UPPER"] = float(groups.group(2))
-                status = "PASS"
+                throughput[u"LOWER"] = float(groups.group(1))
+                throughput[u"UPPER"] = float(groups.group(2))
+                status = u"PASS"

             except (IndexError, ValueError):
                 pass
 
             except (IndexError, ValueError):
                 pass
 


@@ -660,32 +598,62 @@ class ExecutionChecker(ResultVisitor):
         :returns: Parsed data as a dict and the status (PASS/FAIL).
         :rtype: tuple(dict, str)
         """
         :returns: Parsed data as a dict and the status (PASS/FAIL).
         :rtype: tuple(dict, str)
         """

-
+        latency_default = {
+            u"min": -1.0,
+            u"avg": -1.0,
+            u"max": -1.0,
+            u"hdrh": u""
+        }

         latency = {
         latency = {

-            "NDR": {
-                "direction1": {"min": -1.0, "avg": -1.0, "max": -1.0},
-                "direction2": {"min": -1.0, "avg": -1.0, "max": -1.0}
+            u"NDR": {
+                u"direction1": copy.copy(latency_default),
+                u"direction2": copy.copy(latency_default)

             },
             },

-            "PDR": {
-                "direction1": {"min": -1.0, "avg": -1.0, "max": -1.0},
-                "direction2": {"min": -1.0, "avg": -1.0, "max": -1.0}
+            u"PDR": {
+                u"direction1": copy.copy(latency_default),
+                u"direction2": copy.copy(latency_default)

             }
         }
             }
         }

-        status = "FAIL"
+        status = u"FAIL"

         groups = re.search(self.REGEX_NDRPDR_LAT, msg)
 
         groups = re.search(self.REGEX_NDRPDR_LAT, msg)
 

+        def process_latency(in_str):
+            """Return object with parsed latency values.
+
+            TODO: Define class for the return type.
+
+            :param in_str: Input string, min/avg/max/hdrh format.
+            :type in_str: str
+            :returns: Dict with corresponding keys, except hdrh float values.
+            :rtype dict:
+            :throws IndexError: If in_str does not have enough substrings.
+            :throws ValueError: If a substring does not convert to float.
+            """
+            in_list = in_str.split('/', 3)
+
+            rval = {
+                u"min": float(in_list[0]),
+                u"avg": float(in_list[1]),
+                u"max": float(in_list[2]),
+                u"hdrh": u""
+            }
+
+            if len(in_list) == 4:
+                rval[u"hdrh"] = str(in_list[3])
+
+            return rval
+

         if groups is not None:
         if groups is not None:

-            keys = ("min", "avg", "max")

             try:
             try:

-                latency["NDR"]["direction1"] = dict(
-                    zip(keys, [float(l) for l in groups.group(1).split('/')]))
-                latency["NDR"]["direction2"] = dict(
-                    zip(keys, [float(l) for l in groups.group(2).split('/')]))
-                latency["PDR"]["direction1"] = dict(
-                    zip(keys, [float(l) for l in groups.group(3).split('/')]))
-                latency["PDR"]["direction2"] = dict(
-                    zip(keys, [float(l) for l in groups.group(4).split('/')]))
-                status = "PASS"
+                latency[u"NDR"][u"direction1"] = \
+                    process_latency(groups.group(1))
+                latency[u"NDR"][u"direction2"] = \
+                    process_latency(groups.group(2))
+                latency[u"PDR"][u"direction1"] = \
+                    process_latency(groups.group(3))
+                latency[u"PDR"][u"direction2"] = \
+                    process_latency(groups.group(4))
+                status = u"PASS"

             except (IndexError, ValueError):
                 pass
 
             except (IndexError, ValueError):
                 pass
 


@@ -716,17 +684,22 @@ class ExecutionChecker(ResultVisitor):
         except AttributeError:
             return
 
         except AttributeError:
             return
 

-        doc_str = suite.doc.replace('"', "'").replace('\n', ' ').\
-            replace('\r', '').replace('*[', ' |br| *[').replace("*", "**")
-        doc_str = replace(doc_str, ' |br| *[', '*[', maxreplace=1)
-
-        self._data["suites"][suite.longname.lower().replace('"', "'").
-            replace(" ", "_")] = {
-                "name": suite.name.lower(),
-                "doc": doc_str,
-                "parent": parent_name,
-                "level": len(suite.longname.split("."))
-            }
+        doc_str = suite.doc.\
+            replace(u'"', u"'").\
+            replace(u'\n', u' ').\
+            replace(u'\r', u'').\
+            replace(u'*[', u' |br| *[').\
+            replace(u"*", u"**").\
+            replace(u' |br| *[', u'*[', 1)
+
+        self._data[u"suites"][suite.longname.lower().
+                              replace(u'"', u"'").
+                              replace(u" ", u"_")] = {
+                                  u"name": suite.name.lower(),
+                                  u"doc": doc_str,
+                                  u"parent": parent_name,
+                                  u"level": len(suite.longname.split(u"."))
+                              }

 
         suite.keywords.visit(self)
 
 
         suite.keywords.visit(self)
 


@@ -737,7 +710,6 @@ class ExecutionChecker(ResultVisitor):
         :type suite: Suite
         :returns: Nothing.
         """
         :type suite: Suite
         :returns: Nothing.
         """

-        pass

 
     def visit_test(self, test):
         """Implements traversing through the test.
 
     def visit_test(self, test):
         """Implements traversing through the test.


@@ -770,142 +742,120 @@ class ExecutionChecker(ResultVisitor):
         # Change the TC long name and name if defined in the mapping table
         longname = self._mapping.get(longname_orig, None)
         if longname is not None:
         # Change the TC long name and name if defined in the mapping table
         longname = self._mapping.get(longname_orig, None)
         if longname is not None:

-            name = longname.split('.')[-1]
-            logging.debug("{0}\n{1}\n{2}\n{3}".format(
-                self._data["metadata"], longname_orig, longname, name))
+            name = longname.split(u'.')[-1]
+            logging.debug(
+                f"{self._data[u'metadata']}\n{longname_orig}\n{longname}\n"
+                f"{name}"
+            )

         else:
             longname = longname_orig
             name = test.name.lower()
 
         # Remove TC number from the TC long name (backward compatibility):
         else:
             longname = longname_orig
             name = test.name.lower()
 
         # Remove TC number from the TC long name (backward compatibility):

-        self._test_ID = re.sub(self.REGEX_TC_NUMBER, "", longname)
+        self._test_id = re.sub(self.REGEX_TC_NUMBER, u"", longname)

         # Remove TC number from the TC name (not needed):
         # Remove TC number from the TC name (not needed):

-        test_result["name"] = re.sub(self.REGEX_TC_NUMBER, "", name)
-
-        test_result["parent"] = test.parent.name.lower()
-        test_result["tags"] = tags
-        doc_str = test.doc.replace('"', "'").replace('\n', ' '). \
-            replace('\r', '').replace('[', ' |br| [')
-        test_result["doc"] = replace(doc_str, ' |br| [', '[', maxreplace=1)
-        test_result["msg"] = test.message.replace('\n', ' |br| '). \
-            replace('\r', '').replace('"', "'")
-        test_result["type"] = "FUNC"
-        test_result["status"] = test.status
-
-        if "PERFTEST" in tags:
+        test_result[u"name"] = re.sub(self.REGEX_TC_NUMBER, "", name)
+
+        test_result[u"parent"] = test.parent.name.lower()
+        test_result[u"tags"] = tags
+        test_result["doc"] = test.doc.\
+            replace(u'"', u"'").\
+            replace(u'\n', u' ').\
+            replace(u'\r', u'').\
+            replace(u'[', u' |br| [').\
+            replace(u' |br| [', u'[', 1)
+        test_result[u"msg"] = test.message.\
+            replace(u'\n', u' |br| ').\
+            replace(u'\r', u'').\
+            replace(u'"', u"'")
+        test_result[u"type"] = u"FUNC"
+        test_result[u"status"] = test.status
+
+        if u"PERFTEST" in tags:

             # Replace info about cores (e.g. -1c-) with the info about threads
             # and cores (e.g. -1t1c-) in the long test case names and in the
             # test case names if necessary.
             # Replace info about cores (e.g. -1c-) with the info about threads
             # and cores (e.g. -1t1c-) in the long test case names and in the
             # test case names if necessary.

-            groups = re.search(self.REGEX_TC_NAME_OLD, self._test_ID)
+            groups = re.search(self.REGEX_TC_NAME_OLD, self._test_id)

             if not groups:
                 tag_count = 0
             if not groups:
                 tag_count = 0

-                for tag in test_result["tags"]:
+                tag_tc = str()
+                for tag in test_result[u"tags"]:

                     groups = re.search(self.REGEX_TC_TAG, tag)
                     if groups:
                         tag_count += 1
                         tag_tc = tag
 
                 if tag_count == 1:
                     groups = re.search(self.REGEX_TC_TAG, tag)
                     if groups:
                         tag_count += 1
                         tag_tc = tag
 
                 if tag_count == 1:

-                    self._test_ID = re.sub(self.REGEX_TC_NAME_NEW,
-                                           "-{0}-".format(tag_tc.lower()),
-                                           self._test_ID,
+                    self._test_id = re.sub(self.REGEX_TC_NAME_NEW,
+                                           f"-{tag_tc.lower()}-",
+                                           self._test_id,

                                            count=1)
                                            count=1)

-                    test_result["name"] = re.sub(self.REGEX_TC_NAME_NEW,
-                                                 "-{0}-".format(tag_tc.lower()),
-                                                 test_result["name"],
-                                                 count=1)
+                    test_result[u"name"] = re.sub(self.REGEX_TC_NAME_NEW,
+                                                  f"-{tag_tc.lower()}-",
+                                                  test_result["name"],
+                                                  count=1)

                 else:
                 else:

-                    test_result["status"] = "FAIL"
-                    self._data["tests"][self._test_ID] = test_result
-                    logging.debug("The test '{0}' has no or more than one "
-                                  "multi-threading tags.".format(self._test_ID))
-                    logging.debug("Tags: {0}".format(test_result["tags"]))
+                    test_result[u"status"] = u"FAIL"
+                    self._data[u"tests"][self._test_id] = test_result
+                    logging.debug(
+                        f"The test {self._test_id} has no or more than one "
+                        f"multi-threading tags.\n"
+                        f"Tags: {test_result[u'tags']}"
+                    )

                     return
 
                     return
 

-        if test.status == "PASS" and ("NDRPDRDISC" in tags or
-                                      "NDRPDR" in tags or
-                                      "SOAK" in tags or
-                                      "TCP" in tags or
-                                      "MRR" in tags or
-                                      "BMRR" in tags):
-            # TODO: Remove when definitely no NDRPDRDISC tests are used:
-            if "NDRDISC" in tags:
-                test_result["type"] = "NDR"
-            # TODO: Remove when definitely no NDRPDRDISC tests are used:
-            elif "PDRDISC" in tags:
-                test_result["type"] = "PDR"
-            elif "NDRPDR" in tags:
-                test_result["type"] = "NDRPDR"
-            elif "SOAK" in tags:
-                test_result["type"] = "SOAK"
-            elif "TCP" in tags:
-                test_result["type"] = "TCP"
-            elif "MRR" in tags:
-                test_result["type"] = "MRR"
-            elif "FRMOBL" in tags or "BMRR" in tags:
-                test_result["type"] = "BMRR"
-            else:
-                test_result["status"] = "FAIL"
-                self._data["tests"][self._test_ID] = test_result
-                return
-
-            # TODO: Remove when definitely no NDRPDRDISC tests are used:
-            if test_result["type"] in ("NDR", "PDR"):
-                try:
-                    rate_value = str(re.search(
-                        self.REGEX_RATE, test.message).group(1))
-                except AttributeError:
-                    rate_value = "-1"
-                try:
-                    rate_unit = str(re.search(
-                        self.REGEX_RATE, test.message).group(2))
-                except AttributeError:
-                    rate_unit = "-1"
-
-                test_result["throughput"] = dict()
-                test_result["throughput"]["value"] = \
-                    int(rate_value.split('.')[0])
-                test_result["throughput"]["unit"] = rate_unit
-                test_result["latency"] = \
-                    self._get_latency(test.message, test_result["type"])
-                if test_result["type"] == "PDR":
-                    test_result["lossTolerance"] = str(re.search(
-                        self.REGEX_TOLERANCE, test.message).group(1))
-
-            elif test_result["type"] in ("NDRPDR", ):
-                test_result["throughput"], test_result["status"] = \
+        if test.status == u"PASS":
+            if u"NDRPDR" in tags:
+                test_result[u"type"] = u"NDRPDR"
+                test_result[u"throughput"], test_result[u"status"] = \

                     self._get_ndrpdr_throughput(test.message)
                     self._get_ndrpdr_throughput(test.message)

-                test_result["latency"], test_result["status"] = \
+                test_result[u"latency"], test_result[u"status"] = \

                     self._get_ndrpdr_latency(test.message)
                     self._get_ndrpdr_latency(test.message)

-
-            elif test_result["type"] in ("SOAK", ):
-                test_result["throughput"], test_result["status"] = \
+            elif u"SOAK" in tags:
+                test_result[u"type"] = u"SOAK"
+                test_result[u"throughput"], test_result[u"status"] = \

                     self._get_plr_throughput(test.message)
                     self._get_plr_throughput(test.message)

-
-            elif test_result["type"] in ("TCP", ):
+            elif u"TCP" in tags:
+                test_result[u"type"] = u"TCP"

                 groups = re.search(self.REGEX_TCP, test.message)
                 groups = re.search(self.REGEX_TCP, test.message)

-                test_result["result"] = int(groups.group(2))
+                test_result[u"result"] = int(groups.group(2))
+            elif u"MRR" in tags or u"FRMOBL" in tags or u"BMRR" in tags:
+                if u"MRR" in tags:
+                    test_result[u"type"] = u"MRR"
+                else:
+                    test_result[u"type"] = u"BMRR"

 
 

-            elif test_result["type"] in ("MRR", "BMRR"):
-                test_result["result"] = dict()
+                test_result[u"result"] = dict()

                 groups = re.search(self.REGEX_BMRR, test.message)
                 if groups is not None:
                     items_str = groups.group(1)
                     items_float = [float(item.strip()) for item
                                    in items_str.split(",")]
                 groups = re.search(self.REGEX_BMRR, test.message)
                 if groups is not None:
                     items_str = groups.group(1)
                     items_float = [float(item.strip()) for item
                                    in items_str.split(",")]

-                    metadata = AvgStdevMetadataFactory.from_data(items_float)
-                    # Next two lines have been introduced in CSIT-1179,
-                    # to be removed in CSIT-1180.
-                    metadata.size = 1
-                    metadata.stdev = 0.0
-                    test_result["result"]["receive-rate"] = metadata
+                    # Use whole list in CSIT-1180.
+                    stats = jumpavg.AvgStdevStats.for_runs(items_float)
+                    test_result[u"result"][u"receive-rate"] = stats.avg

                 else:
                     groups = re.search(self.REGEX_MRR, test.message)
                 else:
                     groups = re.search(self.REGEX_MRR, test.message)

-                    test_result["result"]["receive-rate"] = \
-                        AvgStdevMetadataFactory.from_data([
-                            float(groups.group(3)) / float(groups.group(1)), ])
+                    test_result[u"result"][u"receive-rate"] = \
+                        float(groups.group(3)) / float(groups.group(1))
+            elif u"RECONF" in tags:
+                test_result[u"type"] = u"RECONF"
+                test_result[u"result"] = None
+                try:
+                    grps_loss = re.search(self.REGEX_RECONF_LOSS, test.message)
+                    grps_time = re.search(self.REGEX_RECONF_TIME, test.message)
+                    test_result[u"result"] = {
+                        u"loss": int(grps_loss.group(1)),
+                        u"time": float(grps_time.group(1))
+                    }
+                except (AttributeError, IndexError, ValueError, TypeError):
+                    test_result[u"status"] = u"FAIL"
+            else:
+                test_result[u"status"] = u"FAIL"
+                self._data[u"tests"][self._test_id] = test_result
+                return

 
 

-        self._data["tests"][self._test_ID] = test_result
+        self._data[u"tests"][self._test_id] = test_result

 
     def end_test(self, test):
         """Called when test ends.
 
     def end_test(self, test):
         """Called when test ends.


@@ -914,7 +864,6 @@ class ExecutionChecker(ResultVisitor):
         :type test: Test
         :returns: Nothing.
         """
         :type test: Test
         :returns: Nothing.
         """

-        pass

 
     def visit_keyword(self, keyword):
         """Implements traversing through the keyword and its child keywords.
 
     def visit_keyword(self, keyword):
         """Implements traversing through the keyword and its child keywords.


@@ -934,9 +883,9 @@ class ExecutionChecker(ResultVisitor):
         :returns: Nothing.
         """
         try:
         :returns: Nothing.
         """
         try:

-            if keyword.type == "setup":
+            if keyword.type == u"setup":

                 self.visit_setup_kw(keyword)
                 self.visit_setup_kw(keyword)

-            elif keyword.type == "teardown":
+            elif keyword.type == u"teardown":

                 self._lookup_kw_nr = 0
                 self.visit_teardown_kw(keyword)
             else:
                 self._lookup_kw_nr = 0
                 self.visit_teardown_kw(keyword)
             else:


@@ -952,7 +901,6 @@ class ExecutionChecker(ResultVisitor):
         :type keyword: Keyword
         :returns: Nothing.
         """
         :type keyword: Keyword
         :returns: Nothing.
         """

-        pass

 
     def visit_test_kw(self, test_kw):
         """Implements traversing through the test keyword and its child
 
     def visit_test_kw(self, test_kw):
         """Implements traversing through the test keyword and its child


@@ -975,12 +923,12 @@ class ExecutionChecker(ResultVisitor):
         :type test_kw: Keyword
         :returns: Nothing.
         """
         :type test_kw: Keyword
         :returns: Nothing.
         """

-        if test_kw.name.count("Show Runtime Counters On All Duts"):
+        if test_kw.name.count(u"Show Runtime Counters On All Duts"):

             self._lookup_kw_nr += 1
             self._show_run_lookup_nr = 0
             self._lookup_kw_nr += 1
             self._show_run_lookup_nr = 0

-            self._msg_type = "test-show-runtime"
-        elif test_kw.name.count("Install Dpdk Test") and not self._version:
-            self._msg_type = "dpdk-version"
+            self._msg_type = u"test-show-runtime"
+        elif test_kw.name.count(u"Install Dpdk Test") and not self._version:
+            self._msg_type = u"dpdk-version"

         else:
             return
         test_kw.messages.visit(self)
         else:
             return
         test_kw.messages.visit(self)


@@ -992,7 +940,6 @@ class ExecutionChecker(ResultVisitor):
         :type test_kw: Keyword
         :returns: Nothing.
         """
         :type test_kw: Keyword
         :returns: Nothing.
         """

-        pass

 
     def visit_setup_kw(self, setup_kw):
         """Implements traversing through the teardown keyword and its child
 
     def visit_setup_kw(self, setup_kw):
         """Implements traversing through the teardown keyword and its child


@@ -1015,14 +962,14 @@ class ExecutionChecker(ResultVisitor):
         :type setup_kw: Keyword
         :returns: Nothing.
         """
         :type setup_kw: Keyword
         :returns: Nothing.
         """

-        if setup_kw.name.count("Show Vpp Version On All Duts") \
+        if setup_kw.name.count(u"Show Vpp Version On All Duts") \

                 and not self._version:
                 and not self._version:

-            self._msg_type = "vpp-version"
-        elif setup_kw.name.count("Set Global Variable") \
+            self._msg_type = u"vpp-version"
+        elif setup_kw.name.count(u"Set Global Variable") \

                 and not self._timestamp:
                 and not self._timestamp:

-            self._msg_type = "timestamp"
-        elif setup_kw.name.count("Setup Framework") and not self._testbed:
-            self._msg_type = "testbed"
+            self._msg_type = u"timestamp"
+        elif setup_kw.name.count(u"Setup Framework") and not self._testbed:
+            self._msg_type = u"testbed"

         else:
             return
         setup_kw.messages.visit(self)
         else:
             return
         setup_kw.messages.visit(self)


@@ -1034,7 +981,6 @@ class ExecutionChecker(ResultVisitor):
         :type setup_kw: Keyword
         :returns: Nothing.
         """
         :type setup_kw: Keyword
         :returns: Nothing.
         """

-        pass

 
     def visit_teardown_kw(self, teardown_kw):
         """Implements traversing through the teardown keyword and its child
 
     def visit_teardown_kw(self, teardown_kw):
         """Implements traversing through the teardown keyword and its child


@@ -1050,21 +996,21 @@ class ExecutionChecker(ResultVisitor):
                 self.end_teardown_kw(keyword)
 
     def start_teardown_kw(self, teardown_kw):
                 self.end_teardown_kw(keyword)
 
     def start_teardown_kw(self, teardown_kw):

-        """Called when teardown keyword starts. Default implementation does
-        nothing.
+        """Called when teardown keyword starts

 
         :param teardown_kw: Keyword to process.
         :type teardown_kw: Keyword
         :returns: Nothing.
         """
 
 
         :param teardown_kw: Keyword to process.
         :type teardown_kw: Keyword
         :returns: Nothing.
         """
 

-        if teardown_kw.name.count("Show Vat History On All Duts"):
+        if teardown_kw.name.count(u"Show Vat History On All Duts"):
+            # TODO: Remove when not needed:

             self._conf_history_lookup_nr = 0
             self._conf_history_lookup_nr = 0

-            self._msg_type = "teardown-vat-history"
+            self._msg_type = u"teardown-vat-history"

             teardown_kw.messages.visit(self)
             teardown_kw.messages.visit(self)

-        elif teardown_kw.name.count("Show Papi History On All Duts"):
+        elif teardown_kw.name.count(u"Show Papi History On All Duts"):

             self._conf_history_lookup_nr = 0
             self._conf_history_lookup_nr = 0

-            self._msg_type = "teardown-papi-history"
+            self._msg_type = u"teardown-papi-history"

             teardown_kw.messages.visit(self)
 
     def end_teardown_kw(self, teardown_kw):
             teardown_kw.messages.visit(self)
 
     def end_teardown_kw(self, teardown_kw):


@@ -1074,7 +1020,6 @@ class ExecutionChecker(ResultVisitor):
         :type teardown_kw: Keyword
         :returns: Nothing.
         """
         :type teardown_kw: Keyword
         :returns: Nothing.
         """

-        pass

 
     def visit_message(self, msg):
         """Implements visiting the message.
 
     def visit_message(self, msg):
         """Implements visiting the message.


@@ -1105,10 +1050,9 @@ class ExecutionChecker(ResultVisitor):
         :type msg: Message
         :returns: Nothing.
         """
         :type msg: Message
         :returns: Nothing.
         """

-        pass

 
 
 
 

-class InputData(object):
+class InputData:

     """Input data
 
     The data is extracted from output.xml files generated by Jenkins jobs and
     """Input data
 
     The data is extracted from output.xml files generated by Jenkins jobs and


@@ -1158,7 +1102,7 @@ class InputData(object):
         :rtype: pandas.Series
         """
 
         :rtype: pandas.Series
         """
 

-        return self.data[job][build]["metadata"]
+        return self.data[job][build][u"metadata"]

 
     def suites(self, job, build):
         """Getter - suites
 
     def suites(self, job, build):
         """Getter - suites


@@ -1171,7 +1115,7 @@ class InputData(object):
         :rtype: pandas.Series
         """
 
         :rtype: pandas.Series
         """
 

-        return self.data[job][str(build)]["suites"]
+        return self.data[job][str(build)][u"suites"]

 
     def tests(self, job, build):
         """Getter - tests
 
     def tests(self, job, build):
         """Getter - tests


@@ -1184,7 +1128,7 @@ class InputData(object):
         :rtype: pandas.Series
         """
 
         :rtype: pandas.Series
         """
 

-        return self.data[job][build]["tests"]
+        return self.data[job][build][u"tests"]

 
     def _parse_tests(self, job, build, log):
         """Process data from robot output.xml file and return JSON structured
 
     def _parse_tests(self, job, build, log):
         """Process data from robot output.xml file and return JSON structured


@@ -1201,16 +1145,18 @@ class InputData(object):
         """
 
         metadata = {
         """
 
         metadata = {

-            "job": job,
-            "build": build
+            u"job": job,
+            u"build": build

         }
 
         }
 

-        with open(build["file-name"], 'r') as data_file:
+        with open(build[u"file-name"], u'r') as data_file:

             try:
                 result = ExecutionResult(data_file)
             except errors.DataError as err:
             try:
                 result = ExecutionResult(data_file)
             except errors.DataError as err:

-                log.append(("ERROR", "Error occurred while parsing output.xml: "
-                                     "{0}".format(err)))
+                log.append(
+                    (u"ERROR", f"Error occurred while parsing output.xml: "
+                               f"{repr(err)}")
+                )

                 return None
         checker = ExecutionChecker(metadata, self._cfg.mapping,
                                    self._cfg.ignore)
                 return None
         checker = ExecutionChecker(metadata, self._cfg.mapping,
                                    self._cfg.ignore)


@@ -1236,10 +1182,11 @@ class InputData(object):
 
         logs = list()
 
 
         logs = list()
 

-        logs.append(("INFO", "  Processing the job/build: {0}: {1}".
-                     format(job, build["build"])))
+        logs.append(
+            (u"INFO", f"  Processing the job/build: {job}: {build[u'build']}")
+        )

 
 

-        state = "failed"
+        state = u"failed"

         success = False
         data = None
         do_repeat = repeat
         success = False
         data = None
         do_repeat = repeat


@@ -1250,78 +1197,70 @@ class InputData(object):
                 break
             do_repeat -= 1
         if not success:
                 break
             do_repeat -= 1
         if not success:

-            logs.append(("ERROR", "It is not possible to download the input "
-                                  "data file from the job '{job}', build "
-                                  "'{build}', or it is damaged. Skipped.".
-                         format(job=job, build=build["build"])))
+            logs.append(
+                (u"ERROR",
+                 f"It is not possible to download the input data file from the "
+                 f"job {job}, build {build[u'build']}, or it is damaged. "
+                 f"Skipped.")
+            )

         if success:
         if success:

-            logs.append(("INFO", "    Processing data from the build '{0}' ...".
-                         format(build["build"])))
+            logs.append(
+                (u"INFO",
+                 f"    Processing data from the build {build[u'build']} ...")
+            )

             data = self._parse_tests(job, build, logs)
             if data is None:
             data = self._parse_tests(job, build, logs)
             if data is None:

-                logs.append(("ERROR", "Input data file from the job '{job}', "
-                                      "build '{build}' is damaged. Skipped.".
-                             format(job=job, build=build["build"])))
+                logs.append(
+                    (u"ERROR",
+                     f"Input data file from the job {job}, build "
+                     f"{build[u'build']} is damaged. Skipped.")
+                )

             else:
             else:

-                state = "processed"
+                state = u"processed"

 
             try:
 
             try:

-                remove(build["file-name"])
+                remove(build[u"file-name"])

             except OSError as err:
             except OSError as err:

-                logs.append(("ERROR", "Cannot remove the file '{0}': {1}".
-                             format(build["file-name"], repr(err))))
+                logs.append(
+                    ("ERROR", f"Cannot remove the file {build[u'file-name']}: "
+                              f"{repr(err)}")
+                )

 
         # If the time-period is defined in the specification file, remove all
         # files which are outside the time period.
 
         # If the time-period is defined in the specification file, remove all
         # files which are outside the time period.

-        timeperiod = self._cfg.input.get("time-period", None)
+        timeperiod = self._cfg.input.get(u"time-period", None)

         if timeperiod and data:
             now = dt.utcnow()
             timeperiod = timedelta(int(timeperiod))
         if timeperiod and data:
             now = dt.utcnow()
             timeperiod = timedelta(int(timeperiod))

-            metadata = data.get("metadata", None)
+            metadata = data.get(u"metadata", None)

             if metadata:
             if metadata:

-                generated = metadata.get("generated", None)
+                generated = metadata.get(u"generated", None)

                 if generated:
                 if generated:

-                    generated = dt.strptime(generated, "%Y%m%d %H:%M")
+                    generated = dt.strptime(generated, u"%Y%m%d %H:%M")

                     if (now - generated) > timeperiod:
                         # Remove the data and the file:
                     if (now - generated) > timeperiod:
                         # Remove the data and the file:

-                        state = "removed"
+                        state = u"removed"

                         data = None
                         logs.append(
                         data = None
                         logs.append(

-                            ("INFO",
-                             "    The build {job}/{build} is outdated, will be "
-                             "removed".format(job=job, build=build["build"])))
-                        file_name = self._cfg.input["file-name"]
-                        full_name = join(
-                            self._cfg.environment["paths"]["DIR[WORKING,DATA]"],
-                            "{job}{sep}{build}{sep}{name}".format(
-                                job=job,
-                                sep=SEPARATOR,
-                                build=build["build"],
-                                name=file_name))
-                        try:
-                            remove(full_name)
-                            logs.append(("INFO",
-                                         "    The file {name} has been removed".
-                                         format(name=full_name)))
-                        except OSError as err:
-                            logs.append(("ERROR",
-                                         "Cannot remove the file '{0}': {1}".
-                                         format(full_name, repr(err))))
-        logs.append(("INFO", "  Done."))
+                            (u"INFO",
+                             f"    The build {job}/{build[u'build']} is "
+                             f"outdated, will be removed.")
+                        )
+        logs.append((u"INFO", u"  Done."))

 
         for level, line in logs:
 
         for level, line in logs:

-            if level == "INFO":
+            if level == u"INFO":

                 logging.info(line)
                 logging.info(line)

-            elif level == "ERROR":
+            elif level == u"ERROR":

                 logging.error(line)
                 logging.error(line)

-            elif level == "DEBUG":
+            elif level == u"DEBUG":

                 logging.debug(line)
                 logging.debug(line)

-            elif level == "CRITICAL":
+            elif level == u"CRITICAL":

                 logging.critical(line)
                 logging.critical(line)

-            elif level == "WARNING":
+            elif level == u"WARNING":

                 logging.warning(line)
 
                 logging.warning(line)
 

-        return {"data": data, "state": state, "job": job, "build": build}
+        return {u"data": data, u"state": state, u"job": job, u"build": build}

 
     def download_and_parse_data(self, repeat=1):
         """Download the input data files, parse input data from input files and
 
     def download_and_parse_data(self, repeat=1):
         """Download the input data files, parse input data from input files and


@@ -1332,41 +1271,48 @@ class InputData(object):
         :type repeat: int
         """
 
         :type repeat: int
         """
 

-        logging.info("Downloading and parsing input files ...")
+        logging.info(u"Downloading and parsing input files ...")

 
         for job, builds in self._cfg.builds.items():
             for build in builds:
 
                 result = self._download_and_parse_build(job, build, repeat)
 
         for job, builds in self._cfg.builds.items():
             for build in builds:
 
                 result = self._download_and_parse_build(job, build, repeat)

-                build_nr = result["build"]["build"]
+                build_nr = result[u"build"][u"build"]

 
 

-                if result["data"]:
-                    data = result["data"]
+                if result[u"data"]:
+                    data = result[u"data"]

                     build_data = pd.Series({
                     build_data = pd.Series({

-                        "metadata": pd.Series(
-                            data["metadata"].values(),
-                            index=data["metadata"].keys()),
-                        "suites": pd.Series(data["suites"].values(),
-                                            index=data["suites"].keys()),
-                        "tests": pd.Series(data["tests"].values(),
-                                           index=data["tests"].keys())})
+                        u"metadata": pd.Series(
+                            list(data[u"metadata"].values()),
+                            index=list(data[u"metadata"].keys())
+                        ),
+                        u"suites": pd.Series(
+                            list(data[u"suites"].values()),
+                            index=list(data[u"suites"].keys())
+                        ),
+                        u"tests": pd.Series(
+                            list(data[u"tests"].values()),
+                            index=list(data[u"tests"].keys())
+                        )
+                    })

 
                     if self._input_data.get(job, None) is None:
                         self._input_data[job] = pd.Series()
                     self._input_data[job][str(build_nr)] = build_data
 
                     self._cfg.set_input_file_name(
 
                     if self._input_data.get(job, None) is None:
                         self._input_data[job] = pd.Series()
                     self._input_data[job][str(build_nr)] = build_data
 
                     self._cfg.set_input_file_name(

-                        job, build_nr, result["build"]["file-name"])
+                        job, build_nr, result[u"build"][u"file-name"])

 
 

-                self._cfg.set_input_state(job, build_nr, result["state"])
+                self._cfg.set_input_state(job, build_nr, result[u"state"])

 
 

-                logging.info("Memory allocation: {0:,d}MB".format(
-                    resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000))
+                mem_alloc = \
+                    resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000
+                logging.info(f"Memory allocation: {mem_alloc:.0f}MB")

 
 

-        logging.info("Done.")
+        logging.info(u"Done.")

 
     @staticmethod
 
     @staticmethod

-    def _end_of_tag(tag_filter, start=0, closer="'"):
+    def _end_of_tag(tag_filter, start=0, closer=u"'"):

         """Return the index of character in the string which is the end of tag.
 
         :param tag_filter: The string where the end of tag is being searched.
         """Return the index of character in the string which is the end of tag.
 
         :param tag_filter: The string where the end of tag is being searched.


@@ -1401,9 +1347,9 @@ class InputData(object):
             if index is None:
                 return tag_filter
             index += 1
             if index is None:
                 return tag_filter
             index += 1

-            tag_filter = tag_filter[:index] + " in tags" + tag_filter[index:]
+            tag_filter = tag_filter[:index] + u" in tags" + tag_filter[index:]

 
 

-    def filter_data(self, element, params=None, data_set="tests",
+    def filter_data(self, element, params=None, data=None, data_set=u"tests",

                     continue_on_error=False):
         """Filter required data from the given jobs and builds.
 
                     continue_on_error=False):
         """Filter required data from the given jobs and builds.
 


@@ -1426,13 +1372,16 @@ class InputData(object):
 
         :param element: Element which will use the filtered data.
         :param params: Parameters which will be included in the output. If None,
 
         :param element: Element which will use the filtered data.
         :param params: Parameters which will be included in the output. If None,

-        all parameters are included.
+            all parameters are included.
+        :param data: If not None, this data is used instead of data specified
+            in the element.

         :param data_set: The set of data to be filtered: tests, suites,
         :param data_set: The set of data to be filtered: tests, suites,

-        metadata.
+            metadata.

         :param continue_on_error: Continue if there is error while reading the
         :param continue_on_error: Continue if there is error while reading the

-        data. The Item will be empty then
+            data. The Item will be empty then

         :type element: pandas.Series
         :type params: list
         :type element: pandas.Series
         :type params: list

+        :type data: dict

         :type data_set: str
         :type continue_on_error: bool
         :returns: Filtered data.
         :type data_set: str
         :type continue_on_error: bool
         :returns: Filtered data.


@@ -1440,59 +1389,156 @@ class InputData(object):
         """
 
         try:
         """
 
         try:

-            if element["filter"] in ("all", "template"):
-                cond = "True"
+            if element[u"filter"] in (u"all", u"template"):
+                cond = u"True"

             else:
             else:

-                cond = InputData._condition(element["filter"])
-            logging.debug("   Filter: {0}".format(cond))
+                cond = InputData._condition(element[u"filter"])
+            logging.debug(f"   Filter: {cond}")

         except KeyError:
         except KeyError:

-            logging.error("  No filter defined.")
+            logging.error(u"  No filter defined.")

             return None
 
         if params is None:
             return None
 
         if params is None:

-            params = element.get("parameters", None)
+            params = element.get(u"parameters", None)

             if params:
             if params:

-                params.append("type")
+                params.append(u"type")

 
 

+        data_to_filter = data if data else element[u"data"]

         data = pd.Series()
         try:
         data = pd.Series()
         try:

-            for job, builds in element["data"].items():
+            for job, builds in data_to_filter.items():

                 data[job] = pd.Series()
                 for build in builds:
                     data[job][str(build)] = pd.Series()
                     try:
                 data[job] = pd.Series()
                 for build in builds:
                     data[job][str(build)] = pd.Series()
                     try:

-                        data_iter = self.data[job][str(build)][data_set].\
-                            iteritems()
+                        data_dict = dict(
+                            self.data[job][str(build)][data_set].items())

                     except KeyError:
                         if continue_on_error:
                             continue
                     except KeyError:
                         if continue_on_error:
                             continue

-                        else:
-                            return None
-                    for test_ID, test_data in data_iter:
-                        if eval(cond, {"tags": test_data.get("tags", "")}):
-                            data[job][str(build)][test_ID] = pd.Series()
+                        return None
+
+                    for test_id, test_data in data_dict.items():
+                        if eval(cond, {u"tags": test_data.get(u"tags", u"")}):
+                            data[job][str(build)][test_id] = pd.Series()

                             if params is None:
                                 for param, val in test_data.items():
                             if params is None:
                                 for param, val in test_data.items():

-                                    data[job][str(build)][test_ID][param] = val
+                                    data[job][str(build)][test_id][param] = val

                             else:
                                 for param in params:
                                     try:
                             else:
                                 for param in params:
                                     try:

-                                        data[job][str(build)][test_ID][param] =\
+                                        data[job][str(build)][test_id][param] =\

                                             test_data[param]
                                     except KeyError:
                                             test_data[param]
                                     except KeyError:

-                                        data[job][str(build)][test_ID][param] =\
-                                            "No Data"
+                                        data[job][str(build)][test_id][param] =\
+                                            u"No Data"

             return data
 
         except (KeyError, IndexError, ValueError) as err:
             return data
 
         except (KeyError, IndexError, ValueError) as err:

-            logging.error("   Missing mandatory parameter in the element "
-                          "specification: {0}".format(err))
+            logging.error(
+                f"Missing mandatory parameter in the element specification: "
+                f"{repr(err)}"
+            )

             return None
             return None

-        except AttributeError:
+        except AttributeError as err:
+            logging.error(repr(err))
+            return None
+        except SyntaxError as err:
+            logging.error(
+                f"The filter {cond} is not correct. Check if all tags are "
+                f"enclosed by apostrophes.\n{repr(err)}"
+            )
+            return None
+
+    def filter_tests_by_name(self, element, params=None, data_set=u"tests",
+                             continue_on_error=False):
+        """Filter required data from the given jobs and builds.
+
+        The output data structure is:
+
+        - job 1
+          - build 1
+            - test (or suite) 1 ID:
+              - param 1
+              - param 2
+              ...
+              - param n
+            ...
+            - test (or suite) n ID:
+            ...
+          ...
+          - build n
+        ...
+        - job n
+
+        :param element: Element which will use the filtered data.
+        :param params: Parameters which will be included in the output. If None,
+        all parameters are included.
+        :param data_set: The set of data to be filtered: tests, suites,
+        metadata.
+        :param continue_on_error: Continue if there is error while reading the
+        data. The Item will be empty then
+        :type element: pandas.Series
+        :type params: list
+        :type data_set: str
+        :type continue_on_error: bool
+        :returns: Filtered data.
+        :rtype pandas.Series
+        """
+
+        include = element.get(u"include", None)
+        if not include:
+            logging.warning(u"No tests to include, skipping the element.")
+            return None
+
+        if params is None:
+            params = element.get(u"parameters", None)
+            if params:
+                params.append(u"type")
+
+        data = pd.Series()
+        try:
+            for job, builds in element[u"data"].items():
+                data[job] = pd.Series()
+                for build in builds:
+                    data[job][str(build)] = pd.Series()
+                    for test in include:
+                        try:
+                            reg_ex = re.compile(str(test).lower())
+                            for test_id in self.data[job][
+                                    str(build)][data_set].keys():
+                                if re.match(reg_ex, str(test_id).lower()):
+                                    test_data = self.data[job][
+                                        str(build)][data_set][test_id]
+                                    data[job][str(build)][test_id] = pd.Series()
+                                    if params is None:
+                                        for param, val in test_data.items():
+                                            data[job][str(build)][test_id]\
+                                                [param] = val
+                                    else:
+                                        for param in params:
+                                            try:
+                                                data[job][str(build)][
+                                                    test_id][param] = \
+                                                    test_data[param]
+                                            except KeyError:
+                                                data[job][str(build)][
+                                                    test_id][param] = u"No Data"
+                        except KeyError as err:
+                            logging.error(repr(err))
+                            if continue_on_error:
+                                continue
+                            return None
+            return data
+
+        except (KeyError, IndexError, ValueError) as err:
+            logging.error(
+                f"Missing mandatory parameter in the element "
+                f"specification: {repr(err)}"
+            )

             return None
             return None

-        except SyntaxError:
-            logging.error("   The filter '{0}' is not correct. Check if all "
-                          "tags are enclosed by apostrophes.".format(cond))
+        except AttributeError as err:
+            logging.error(repr(err))

             return None
 
     @staticmethod
             return None
 
     @staticmethod


@@ -1516,12 +1562,12 @@ class InputData(object):
         :rtype: pandas.Series
         """
 
         :rtype: pandas.Series
         """
 

-        logging.info("    Merging data ...")
+        logging.info(u"    Merging data ...")

 
         merged_data = pd.Series()
 
         merged_data = pd.Series()

-        for _, builds in data.iteritems():
-            for _, item in builds.iteritems():
-                for ID, item_data in item.iteritems():
-                    merged_data[ID] = item_data
+        for builds in data.values:
+            for item in builds.values:
+                for item_id, item_data in item.items():
+                    merged_data[item_id] = item_data

 
         return merged_data
 
         return merged_data