refactor test framework

Change-Id: I31da3b1857b6399f9899276a2d99cdd19436296c
Signed-off-by: Klement Sekera <ksekera@cisco.com>
Signed-off-by: Matej Klotton <mklotton@cisco.com>
Signed-off-by: Jan Gelety <jgelety@cisco.com>
Signed-off-by: Juraj Sloboda <jsloboda@cisco.com>

1 files changed, 382 insertions, 491 deletions

diff --git a/test/framework.py b/test/framework.py
index 5cf2a250..02ffb7ad 100644
--- a/test/framework.py
+++ b/test/framework.py
@@ -1,424 +1,315 @@
 #!/usr/bin/env python
-## @package framework
-#  Module to handle test case execution.
-#
-#  The module provides a set of tools for constructing and running tests and
-#  representing the results.
-
-import logging
-logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
 
+from abc import *
 import os
 import sys
 import subprocess
 import unittest
+import tempfile
+import resource
+from time import sleep
 from inspect import getdoc
+from hook import PollHook
+from vpp_pg_interface import VppPGInterface
+from vpp_papi_provider import VppPapiProvider
 
-from scapy.utils import wrpcap, rdpcap
 from scapy.packet import Raw
 
-## Static variables to store color formatting strings.
+from logging import *
+
+"""
+  Test framework module.
+
+  The module provides a set of tools for constructing and running tests and
+  representing the results.
+"""
+
+handler = StreamHandler(sys.stdout)
+getLogger().addHandler(handler)
+try:
+    verbose = int(os.getenv("V", 0))
+except:
+    verbose = 0
+# 40 = ERROR, 30 = WARNING, 20 = INFO, 10 = DEBUG, 0 = NOTSET (all messages)
+getLogger().setLevel(40 - 10 * verbose)
+getLogger("scapy.runtime").addHandler(handler)
+getLogger("scapy.runtime").setLevel(ERROR)
+
+# Static variables to store color formatting strings.
 #
-#  These variables (RED, GREEN, YELLOW and LPURPLE) are used to configure
-#  the color of the text to be printed in the terminal. Variable END is used
-#  to revert the text color to the default one.
+# These variables (RED, GREEN, YELLOW and LPURPLE) are used to configure
+# the color of the text to be printed in the terminal. Variable COLOR_RESET
+# is used to revert the text color to the default one.
 if hasattr(sys.stdout, 'isatty') and sys.stdout.isatty():
     RED = '\033[91m'
     GREEN = '\033[92m'
     YELLOW = '\033[93m'
     LPURPLE = '\033[94m'
-    END = '\033[0m'
+    COLOR_RESET = '\033[0m'
 else:
     RED = ''
     GREEN = ''
     YELLOW = ''
     LPURPLE = ''
-    END = ''
+    COLOR_RESET = ''
+
+
+""" @var formatting delimiter consisting of '=' characters """
+double_line_delim = '=' * 70
+""" @var formatting delimiter consisting of '-' characters """
+single_line_delim = '-' * 70
 
 
-## Private class to create packet info object.
-#
-#  Help process information about the next packet.
-#  Set variables to default values.
 class _PacketInfo(object):
+    """Private class to create packet info object.
+
+    Help process information about the next packet.
+    Set variables to default values.
+    @property index
+      Integer variable to store the index of the packet.
+    @property src
+      Integer variable to store the index of the source packet generator
+      interface of the packet.
+    @property dst
+      Integer variable to store the index of the destination packet generator
+      interface of the packet.
+    @property data
+      Object variable to store the copy of the former packet.
+
+
+    """
     index = -1
     src = -1
     dst = -1
     data = None
-    ## @var index
-    #  Integer variable to store the index of the packet.
-    ## @var src
-    #  Integer variable to store the index of the source packet generator
-    #  interface of the packet.
-    ## @var dst
-    #  Integer variable to store the index of the destination packet generator
-    #  interface of the packet.
-    ## @var data
-    #  Object variable to store the copy of the former packet.
-
-## Subclass of the python unittest.TestCase class.
-#
-#  This subclass is a base class for test cases that are implemented as classes.
-#  It provides methods to create and run test case.
+
+
 class VppTestCase(unittest.TestCase):
+    """
+    Subclass of the python unittest.TestCase class.
+
+    This subclass is a base class for test cases that are implemented as classes
+    It provides methods to create and run test case.
+
+    """
+
+    @property
+    def packet_infos(self):
+        """List of packet infos"""
+        return self._packet_infos
+
+    @packet_infos.setter
+    def packet_infos(self, value):
+        self._packet_infos = value
+
+    @classmethod
+    def instance(cls):
+        """Return the instance of this testcase"""
+        return cls.test_instance
 
-    ## Class method to set class constants necessary to run test case.
-    #  @param cls The class pointer.
     @classmethod
     def setUpConstants(cls):
+        """ Set-up the test case class based on environment variables """
+        try:
+            cls.interactive = True if int(os.getenv("I")) > 0 else False
+        except:
+            cls.interactive = False
+        if cls.interactive and resource.getrlimit(resource.RLIMIT_CORE)[0] <= 0:
+            # give a heads up if this is actually useless
+            critical("WARNING: core size limit is set 0, core files will NOT "
+                     "be created")
         cls.vpp_bin = os.getenv('VPP_TEST_BIN', "vpp")
         cls.plugin_path = os.getenv('VPP_TEST_PLUGIN_PATH')
-        cls.vpp_api_test_bin = os.getenv("VPP_TEST_API_TEST_BIN",
-                                         "vpp-api-test")
-        cls.vpp_cmdline = [cls.vpp_bin, "unix", "nodaemon", "api-segment", "{",
-                           "prefix", "unittest", "}"]
+        cls.vpp_cmdline = [cls.vpp_bin, "unix", "nodaemon",
+                           "api-segment", "{", "prefix", cls.shm_prefix, "}"]
         if cls.plugin_path is not None:
             cls.vpp_cmdline.extend(["plugin_path", cls.plugin_path])
+        info("vpp_cmdline: %s" % cls.vpp_cmdline)
 
-        cls.vpp_api_test_cmdline = [cls.vpp_api_test_bin, "chroot", "prefix",
-                                    "unittest"]
-        try:
-            cls.verbose = int(os.getenv("V", 0))
-        except:
-            cls.verbose = 0
-
-        ## @var vpp_bin
-        #  String variable to store the path to vpp (vector packet processor).
-        ## @var vpp_api_test_bin
-        #  String variable to store the path to vpp_api_test (vpp API test tool).
-        ## @var vpp_cmdline
-        #  List of command line attributes for vpp.
-        ## @var vpp_api_test_cmdline
-        #  List of command line attributes for vpp_api_test.
-        ## @var verbose
-        #  Integer variable to store required verbosity level.
-
-    ## Class method to start the test case.
-    #  1. Initiate test case constants and set test case variables to default
-    #  values.
-    #  2. Remove files from the shared memory.
-    #  3. Start vpp as a subprocess.
-    #  @param cls The class pointer.
     @classmethod
     def setUpClass(cls):
+        """
+        Perform class setup before running the testcase
+        Remove shared memory files, start vpp and connect the vpp-api
+        """
+        cls.tempdir = tempfile.mkdtemp(
+            prefix='vpp-unittest-' + cls.__name__ + '-')
+        cls.shm_prefix = cls.tempdir.split("/")[-1]
+        os.chdir(cls.tempdir)
+        info("Temporary dir is %s, shm prefix is %s",
+             cls.tempdir, cls.shm_prefix)
         cls.setUpConstants()
         cls.pg_streams = []
-        cls.MY_MACS = {}
-        cls.MY_IP4S = {}
-        cls.MY_IP6S = {}
-        cls.VPP_MACS = {}
-        cls.VPP_IP4S = {}
-        cls.VPP_IP6S = {}
         cls.packet_infos = {}
-        print "=================================================================="
-        print YELLOW + getdoc(cls) + END
-        print "=================================================================="
-        os.system("rm -f /dev/shm/unittest-global_vm")
-        os.system("rm -f /dev/shm/unittest-vpe-api")
-        os.system("rm -f /dev/shm/unittest-db")
-        cls.vpp = subprocess.Popen(cls.vpp_cmdline, stderr=subprocess.PIPE)
-        ## @var pg_streams
-        #  List variable to store packet-generator streams for interfaces.
-        ## @var MY_MACS
-        #  Dictionary variable to store host MAC addresses connected to packet
-        #  generator interfaces.
-        ## @var MY_IP4S
-        #  Dictionary variable to store host IPv4 addresses connected to packet
-        #  generator interfaces.
-        ## @var MY_IP6S
-        #  Dictionary variable to store host IPv6 addresses connected to packet
-        #  generator interfaces.
-        ## @var VPP_MACS
-        #  Dictionary variable to store VPP MAC addresses of the packet
-        #  generator interfaces.
-        ## @var VPP_IP4S
-        #  Dictionary variable to store VPP IPv4 addresses of the packet
-        #  generator interfaces.
-        ## @var VPP_IP6S
-        #  Dictionary variable to store VPP IPv6 addresses of the packet
-        #  generator interfaces.
-        ## @var vpp
-        #  Test case object variable to store file descriptor of running vpp
-        #  subprocess with open pipe to the standard error stream per
-        #  VppTestCase object.
-
-    ## Class method to do cleaning when all tests (test_) defined for
-    #  VppTestCase class are finished.
-    #  1. Terminate vpp and kill all vpp instances.
-    #  2. Remove files from the shared memory.
-    #  @param cls The class pointer.
+        cls.verbose = 0
+        print(double_line_delim)
+        print(YELLOW + getdoc(cls) + COLOR_RESET)
+        print(double_line_delim)
+        # need to catch exceptions here because if we raise, then the cleanup
+        # doesn't get called and we might end with a zombie vpp
+        try:
+            cls.vpp = subprocess.Popen(cls.vpp_cmdline, stderr=subprocess.PIPE)
+            debug("Spawned VPP with PID: %d" % cls.vpp.pid)
+            cls.vpp_dead = False
+            cls.vapi = VppPapiProvider(cls.shm_prefix, cls.shm_prefix)
+            cls.vapi.register_hook(PollHook(cls))
+            cls.vapi.connect()
+        except:
+            cls.vpp.terminate()
+            del cls.vpp
+
     @classmethod
     def quit(cls):
-        cls.vpp.terminate()
-        cls.vpp = None
-        os.system("rm -f /dev/shm/unittest-global_vm")
-        os.system("rm -f /dev/shm/unittest-vpe-api")
-        os.system("rm -f /dev/shm/unittest-db")
-
-    ## Class method to define tear down action of the VppTestCase class.
-    #  @param cls The class pointer.
+        """
+        Disconnect vpp-api, kill vpp and cleanup shared memory files
+        """
+        if hasattr(cls, 'vpp'):
+            cls.vapi.disconnect()
+            cls.vpp.poll()
+            if cls.vpp.returncode is None:
+                cls.vpp.terminate()
+            del cls.vpp
+
     @classmethod
     def tearDownClass(cls):
+        """ Perform final cleanup after running all tests in this test-case """
         cls.quit()
 
-    ## Method to define tear down VPP actions of the test case.
-    #  @param self The object pointer.
     def tearDown(self):
-        self.cli(2, "show int")
-        self.cli(2, "show trace")
-        self.cli(2, "show hardware")
-        self.cli(2, "show ip arp")
-        self.cli(2, "show ip fib")
-        self.cli(2, "show error")
-        self.cli(2, "show run")
-
-    ## Method to define setup action of the test case.
-    #  @param self The object pointer.
+        """ Show various debug prints after each test """
+        if not self.vpp_dead:
+            info(self.vapi.cli("show int"))
+            info(self.vapi.cli("show trace"))
+            info(self.vapi.cli("show hardware"))
+            info(self.vapi.cli("show error"))
+            info(self.vapi.cli("show run"))
+
     def setUp(self):
-        self.cli(2, "clear trace")
+        """ Clear trace before running each test"""
+        self.vapi.cli("clear trace")
+        # store the test instance inside the test class - so that objects
+        # holding the class can access instance methods (like assertEqual)
+        type(self).test_instance = self
 
-    ## Class method to print logs.
-    #  Based on set level of verbosity print text in the terminal.
-    #  @param cls The class pointer.
-    #  @param s String variable to store text to be printed.
-    #  @param v Integer variable to store required level of verbosity.
-    @classmethod
-    def log(cls, s, v=1):
-        if cls.verbose >= v:
-            print "LOG: " + LPURPLE + s + END
-
-    ## Class method to execute api commands.
-    #  Based on set level of verbosity print the output of the api command in
-    #  the terminal.
-    #  @param cls The class pointer.
-    #  @param s String variable to store api command string.
-    @classmethod
-    def api(cls, s):
-        p = subprocess.Popen(cls.vpp_api_test_cmdline,
-                             stdout=subprocess.PIPE,
-                             stdin=subprocess.PIPE,
-                             stderr=subprocess.PIPE)
-        if cls.verbose > 0:
-            print "API: " + RED + s + END
-        p.stdin.write(s)
-        out = p.communicate()[0]
-        out = out.replace("vat# ", "", 2)
-        if cls.verbose > 0:
-            if len(out) > 1:
-                print YELLOW + out + END
-        ## @var p
-        #  Object variable to store file descriptor of vpp_api_test subprocess
-        #  with open pipes to the standard output, inputs and error streams.
-        ## @var out
-        #  Tuple variable to store standard output of vpp_api_test subprocess
-        #  where the string "vat# " is replaced by empty string later.
-
-    ## Class method to execute cli commands.
-    #  Based on set level of verbosity of the log and verbosity defined by
-    #  environmental variable execute the cli command and print the output in
-    #  the terminal.
-    #  CLI command is executed via vpp API test tool (exec + cli_command)
-    #  @param cls The class pointer.
-    #  @param v Integer variable to store required level of verbosity.
-    #  @param s String variable to store cli command string.
-    @classmethod
-    def cli(cls, v, s):
-        if cls.verbose < v:
-            return
-        p = subprocess.Popen(cls.vpp_api_test_cmdline,
-                             stdout=subprocess.PIPE,
-                             stdin=subprocess.PIPE,
-                             stderr=subprocess.PIPE)
-        if cls.verbose > 0:
-            print "CLI: " + RED + s + END
-        p.stdin.write('exec ' + s)
-        out = p.communicate()[0]
-        out = out.replace("vat# ", "", 2)
-        if cls.verbose > 0:
-            if len(out) > 1:
-                print YELLOW + out + END
-        ## @var p
-        #  Object variable to store file descriptor of vpp_api_test subprocess
-        #  with open pipes to the standard output, inputs and error streams.
-        ## @var out
-        #  Tuple variable to store standard output of vpp_api_test subprocess
-        #  where the string "vat# " is replaced by empty string later.
-
-    ## Class method to create incoming packet stream for the packet-generator
-    #  interface.
-    #  Delete old /tmp/pgX_in.pcap file if exists and create the empty one and
-    #  fill it with provided packets and add it to pg_streams list.
-    #  @param cls The class pointer.
-    #  @param i Integer variable to store the index of the packet-generator
-    #  interface to create packet stream for.
-    #  @param pkts List variable to store packets to be added to the stream.
     @classmethod
-    def pg_add_stream(cls, i, pkts):
-        os.system("rm -f /tmp/pg%u_in.pcap" % i)
-        wrpcap("/tmp/pg%u_in.pcap" % i, pkts)
-        # no equivalent API command
-        cls.cli(0, "packet-generator new pcap /tmp/pg%u_in.pcap source pg%u"
-                   " name pcap%u" % (i, i, i))
-        cls.pg_streams.append('pcap%u' % i)
-
-    ## Class method to enable packet capturing for the packet-generator
-    #  interface.
-    #  Delete old /tmp/pgX_out.pcap file if exists and set the packet-generator
-    #  to capture outgoing packets to /tmp/pgX_out.pcap file.
-    #  @param cls The class pointer.
-    #  @param args List variable to store the indexes of the packet-generator
-    #  interfaces to start packet capturing for.
-    @classmethod
-    def pg_enable_capture(cls, args):
-        for i in args:
-            os.system("rm -f /tmp/pg%u_out.pcap" % i)
-            cls.cli(0, "packet-generator capture pg%u pcap /tmp/pg%u_out.pcap"
-                    % (i, i))
-
-    ## Class method to start packet sending.
-    #  Start to send packets for all defined pg streams. Delete every stream
-    #  from the stream list when sent and clear the pg_streams list.
-    #  @param cls The class pointer.
+    def pg_enable_capture(cls, interfaces):
+        """
+        Enable capture on packet-generator interfaces
+
+        :param interfaces: iterable interface indexes
+
+        """
+        for i in interfaces:
+            i.enable_capture()
+
     @classmethod
     def pg_start(cls):
-        cls.cli(2, "trace add pg-input 50")  # 50 is maximum
-        cls.cli(0, 'packet-generator enable')
+        """
+        Enable the packet-generator and send all prepared packet streams
+        Remove the packet streams afterwards
+        """
+        cls.vapi.cli("trace add pg-input 50")  # 50 is maximum
+        cls.vapi.cli('packet-generator enable')
+        sleep(1)  # give VPP some time to process the packets
         for stream in cls.pg_streams:
-            cls.cli(0, 'packet-generator delete %s' % stream)
+            cls.vapi.cli('packet-generator delete %s' % stream)
         cls.pg_streams = []
 
-    ## Class method to return captured packets.
-    #  Return packet captured for the defined packet-generator interface. Open
-    #  the corresponding pcap file (/tmp/pgX_out.pcap), read the content and
-    #  store captured packets to output variable.
-    #  @param cls The class pointer.
-    #  @param o Integer variable to store the index of the packet-generator
-    #  interface.
-    #  @return output List of packets captured on the defined packet-generator
-    #  interface. If the corresponding pcap file (/tmp/pgX_out.pcap) does not
-    #  exist return empty list.
-    @classmethod
-    def pg_get_capture(cls, o):
-        pcap_filename = "/tmp/pg%u_out.pcap" % o
-        try:
-            output = rdpcap(pcap_filename)
-        except IOError:  # TODO
-            cls.log("WARNING: File %s does not exist, probably because no"
-                    " packets arrived" % pcap_filename)
-            return []
-        return output
-        ## @var pcap_filename
-        #  File descriptor to the corresponding pcap file.
-
-    ## Class method to create packet-generator interfaces.
-    #  Create packet-generator interfaces and add host MAC addresses connected
-    #  to these packet-generator interfaces to the MY_MACS dictionary.
-    #  @param cls The class pointer.
-    #  @param args List variable to store the indexes of the packet-generator
-    #  interfaces to be created.
     @classmethod
-    def create_interfaces(cls, args):
-        for i in args:
-            cls.MY_MACS[i] = "02:00:00:00:ff:%02x" % i
-            cls.log("My MAC address is %s" % (cls.MY_MACS[i]))
-            cls.api("pg_create_interface if_id %u" % i)
-            cls.api("sw_interface_set_flags pg%u admin-up" % i)
-
-    ## Static method to extend packet to specified size
-    #  Extend provided packet to the specified size (including Ethernet FCS).
-    #  The packet is extended by adding corresponding number of spaces to the
-    #  packet payload.
-    #  NOTE: Currently works only when Raw layer is present.
-    #  @param packet Variable to store packet object.
-    #  @param size Integer variable to store the required size of the packet.
+    def create_pg_interfaces(cls, interfaces):
+        """
+        Create packet-generator interfaces
+
+        :param interfaces: iterable indexes of the interfaces
+
+        """
+        result = []
+        for i in interfaces:
+            intf = VppPGInterface(cls, i)
+            setattr(cls, intf.name, intf)
+            result.append(intf)
+        cls.pg_interfaces = result
+        return result
+
     @staticmethod
     def extend_packet(packet, size):
+        """
+        Extend packet to given size by padding with spaces
+        NOTE: Currently works only when Raw layer is present.
+
+        :param packet: packet
+        :param size: target size
+
+        """
         packet_len = len(packet) + 4
         extend = size - packet_len
         if extend > 0:
             packet[Raw].load += ' ' * extend
-        ## @var packet_len
-        #  Integer variable to store the current packet length including
-        #  Ethernet FCS.
-        ## @var extend
-        #  Integer variable to store the size of the packet extension.
-
-    ## Method to add packet info object to the packet_infos list.
-    #  Extend the existing packet_infos list with the given information from
-    #  the packet.
-    #  @param self The object pointer.
-    #  @param info Object to store required information from the packet.
+
     def add_packet_info_to_list(self, info):
+        """
+        Add packet info to the testcase's packet info list
+
+        :param info: packet info
+
+        """
         info.index = len(self.packet_infos)
         self.packet_infos[info.index] = info
-        ## @var info.index
-        # Info object attribute to store the packet order in the stream.
-        ## @var packet_infos
-        #  List variable to store required information from packets.
-
-    ## Method to create packet info object.
-    #  Create the existing packet_infos list with the given information from
-    #  the packet.
-    #  @param self The object pointer.
-    #  @param pg_id Integer variable to store the index of the packet-generator
-    #  interface.
-    def create_packet_info(self, pg_id, target_id):
+
+    def create_packet_info(self, src_pg_index, dst_pg_index):
+        """
+        Create packet info object containing the source and destination indexes
+        and add it to the testcase's packet info list
+
+        :param src_pg_index: source packet-generator index
+        :param dst_pg_index: destination packet-generator index
+
+        :returns: _PacketInfo object
+
+        """
         info = _PacketInfo()
         self.add_packet_info_to_list(info)
-        info.src = pg_id
-        info.dst = target_id
+        info.src = src_pg_index
+        info.dst = dst_pg_index
         return info
-        ## @var info
-        #  Object to store required information from packet.
-        ## @var info.src
-        #  Info object attribute to store the index of the source packet
-        #  generator interface of the packet.
-        ## @var info.dst
-        #  Info object attribute to store the index of the destination packet
-        #  generator interface of the packet.
-
-    ## Static method to return packet info string.
-    #  Create packet info string from the provided info object that will be put
-    #  to the packet payload.
-    #  @param info Object to store required information from the packet.
-    #  @return String of information about packet's order in the stream, source
-    #  and destination packet generator interface.
+
     @staticmethod
     def info_to_payload(info):
+        """
+        Convert _PacketInfo object to packet payload
+
+        :param info: _PacketInfo object
+
+        :returns: string containing serialized data from packet info
+        """
         return "%d %d %d" % (info.index, info.src, info.dst)
 
-    ## Static method to create packet info object from the packet payload.
-    #  Create packet info object and set its attribute values based on data
-    #  gained from the packet payload.
-    #  @param payload String variable to store packet payload.
-    #  @return info Object to store required information about the packet.
     @staticmethod
     def payload_to_info(payload):
+        """
+        Convert packet payload to _PacketInfo object
+
+        :param payload: packet payload
+
+        :returns: _PacketInfo object containing de-serialized data from payload
+
+        """
         numbers = payload.split()
         info = _PacketInfo()
         info.index = int(numbers[0])
         info.src = int(numbers[1])
         info.dst = int(numbers[2])
         return info
-        ## @var info.index
-        #  Info object attribute to store the packet order in the stream.
-        ## @var info.src
-        #  Info object attribute to store the index of the source packet
-        #  generator interface of the packet.
-        ## @var info.dst
-        #  Info object attribute to store the index of the destination packet
-        #  generator interface of the packet.
-
-    ## Method to return packet info object of the next packet in
-    #  the packet_infos list.
-    #  Get the next packet info object from the packet_infos list by increasing
-    #  the packet_infos list index by one.
-    #  @param self The object pointer.
-    #  @param info Object to store required information about the packet.
-    #  @return packet_infos[next_index] Next info object from the packet_infos
-    #  list with stored information about packets. Return None if the end of
-    #  the list is reached.
+
     def get_next_packet_info(self, info):
+        """
+        Iterate over the packet info list stored in the testcase
+        Start iteration with first element if info is None
+        Continue based on index in info if info is specified
+
+        :param info: info or None
+        :returns: next info in list or None if no more infos
+        """
         if info is None:
             next_index = 0
         else:
@@ -427,208 +318,208 @@ class VppTestCase(unittest.TestCase):
             return None
         else:
             return self.packet_infos[next_index]
-        ## @var next_index
-        #  Integer variable to store the index of the next info object.
-
-    ## Method to return packet info object of the next packet with the required
-    #  source packet generator interface.
-    #  Iterate over the packet_infos list and search for the next packet info
-    #  object with the required source packet generator interface.
-    #  @param self The object pointer.
-    #  @param src_pg Integer variable to store index of requested source packet
-    #  generator interface.
-    #  @param info Object to store required information about the packet.
-    #  @return packet_infos[next_index] Next info object from the packet_infos
-    #  list with stored information about packets. Return None if the end of
-    #  the list is reached.
-    def get_next_packet_info_for_interface(self, src_pg, info):
+
+    def get_next_packet_info_for_interface(self, src_index, info):
+        """
+        Search the packet info list for the next packet info with same source
+        interface index
+
+        :param src_index: source interface index to search for
+        :param info: packet info - where to start the search
+        :returns: packet info or None
+
+        """
         while True:
             info = self.get_next_packet_info(info)
             if info is None:
                 return None
-            if info.src == src_pg:
+            if info.src == src_index:
                 return info
-        ## @var info.src
-        #  Info object attribute to store the index of the source packet
-        #  generator interface of the packet.
-
-    ## Method to return packet info object of the next packet with required
-    #  source and destination packet generator interfaces.
-    #  Search for the next packet info object with the required source and
-    #  destination packet generator interfaces.
-    #  @param self The object pointer.
-    #  @param src_pg Integer variable to store the index of the requested source
-    #  packet generator interface.
-    #  @param dst_pg Integer variable to store the index of the requested source
-    #  packet generator interface.
-    #  @param info Object to store required information about the packet.
-    #  @return info Object with the info about the next packet with with
-    #  required source and destination packet generator interfaces. Return None
-    #  if there is no other packet with required data.
-    def get_next_packet_info_for_interface2(self, src_pg, dst_pg, info):
+
+    def get_next_packet_info_for_interface2(self, src_index, dst_index, info):
+        """
+        Search the packet info list for the next packet info with same source
+        and destination interface indexes
+
+        :param src_index: source interface index to search for
+        :param dst_index: destination interface index to search for
+        :param info: packet info - where to start the search
+        :returns: packet info or None
+
+        """
         while True:
-            info = self.get_next_packet_info_for_interface(src_pg, info)
+            info = self.get_next_packet_info_for_interface(src_index, info)
             if info is None:
                 return None
-            if info.dst == dst_pg:
+            if info.dst == dst_index:
                 return info
-        ## @var info.dst
-        #  Info object attribute to store the index of the destination packet
-        #  generator interface of the packet.
 
 
-## Subclass of the python unittest.TestResult class.
-#
-#  This subclass provides methods to compile information about which tests have
-#  succeeded and which have failed.
 class VppTestResult(unittest.TestResult):
-    ## The constructor.
-    #  @param stream File descriptor to store where to report test results. Set
-    #  to the standard error stream by default.
-    #  @param descriptions Boolean variable to store information if to use test
-    #  case descriptions.
-    #  @param verbosity Integer variable to store required verbosity level.
+    """
+    @property result_string
+     String variable to store the test case result string.
+    @property errors
+     List variable containing 2-tuples of TestCase instances and strings
+     holding formatted tracebacks. Each tuple represents a test which
+     raised an unexpected exception.
+    @property failures
+     List variable containing 2-tuples of TestCase instances and strings
+     holding formatted tracebacks. Each tuple represents a test where
+     a failure was explicitly signalled using the TestCase.assert*()
+     methods.
+    """
+
     def __init__(self, stream, descriptions, verbosity):
+        """
+        :param stream File descriptor to store where to report test results. Set
+            to the standard error stream by default.
+        :param descriptions Boolean variable to store information if to use test
+            case descriptions.
+        :param verbosity Integer variable to store required verbosity level.
+        """
         unittest.TestResult.__init__(self, stream, descriptions, verbosity)
         self.stream = stream
         self.descriptions = descriptions
         self.verbosity = verbosity
         self.result_string = None
-        ## @var result_string
-        #  String variable to store the test case result string.
-
 
-    ## Method called when the test case succeeds.
-    #  Run the default implementation (that does nothing) and set the result
-    #  string in case of test case success.
-    #  @param self The object pointer.
-    #  @param test Object variable to store the test case instance.
     def addSuccess(self, test):
+        """
+        Record a test succeeded result
+
+        :param test:
+
+        """
         unittest.TestResult.addSuccess(self, test)
-        self.result_string = GREEN + "OK" + END
-        ## @var result_string
-        #  String variable to store the test case result string.
-
-    ## Method called when the test case signals a failure.
-    #  Run the default implementation that appends a tuple (test, formatted_err)
-    #  to the instance's failures attribute, where formatted_err is a formatted
-    #  traceback derived from err and set the result string in case of test case
-    #  success.
-    #  @param self The object pointer.
-    #  @param test Object variable to store the test case instance.
-    #  @param err Tuple variable to store the error data:
-    #  (type, value, traceback).
+        self.result_string = GREEN + "OK" + COLOR_RESET
+
+    def addSkip(self, test, reason):
+        """
+        Record a test skipped.
+
+        :param test:
+        :param reason:
+
+        """
+        unittest.TestResult.addSkip(self, test, reason)
+        self.result_string = YELLOW + "SKIP" + COLOR_RESET
+
     def addFailure(self, test, err):
+        """
+        Record a test failed result
+
+        :param test:
+        :param err: error message
+
+        """
         unittest.TestResult.addFailure(self, test, err)
-        self.result_string = RED + "FAIL" + END
-        ## @var result_string
-        #  String variable to store the test case result string.
-
-    ## Method called when the test case raises an unexpected exception.
-    #  Run the default implementation that appends a tuple (test, formatted_err)
-    #  to the instance's error attribute, where formatted_err is a formatted
-    #  traceback derived from err and set the result string in case of test case
-    #  unexpected failure.
-    #  @param self The object pointer.
-    #  @param test Object variable to store the test case instance.
-    #  @param err Tuple variable to store the error data:
-    #  (type, value, traceback).
+        if hasattr(test, 'tempdir'):
+            self.result_string = RED + "FAIL" + COLOR_RESET + \
+                ' [ temp dir used by test case: ' + test.tempdir + ' ]'
+        else:
+            self.result_string = RED + "FAIL" + COLOR_RESET + ' [no temp dir]'
+
     def addError(self, test, err):
+        """
+        Record a test error result
+
+        :param test:
+        :param err: error message
+
+        """
         unittest.TestResult.addError(self, test, err)
-        self.result_string = RED + "ERROR" + END
-        ## @var result_string
-        #  String variable to store the test case result string.
-
-    ## Method to get the description of the test case.
-    #  Used to get the description string from the test case object.
-    #  @param self The object pointer.
-    #  @param test Object variable to store the test case instance.
-    #  @return String of the short description if exist otherwise return test
-    #  case name string.
+        if hasattr(test, 'tempdir'):
+            self.result_string = RED + "ERROR" + COLOR_RESET + \
+                ' [ temp dir used by test case: ' + test.tempdir + ' ]'
+        else:
+            self.result_string = RED + "ERROR" + COLOR_RESET + ' [no temp dir]'
+
     def getDescription(self, test):
+        """
+        Get test description
+
+        :param test:
+        :returns: test description
+
+        """
         # TODO: if none print warning not raise exception
         short_description = test.shortDescription()
         if self.descriptions and short_description:
             return short_description
         else:
             return str(test)
-        ## @var short_description
-        #  String variable to store the short description of the test case.
-
-    ## Method called when the test case is about to be run.
-    #  Run the default implementation and based on the set verbosity level write
-    #  the starting string to the output stream.
-    #  @param self The object pointer.
-    #  @param test Object variable to store the test case instance.
+
     def startTest(self, test):
+        """
+        Start a test
+
+        :param test:
+
+        """
         unittest.TestResult.startTest(self, test)
         if self.verbosity > 0:
-            self.stream.writeln("Starting " + self.getDescription(test) + " ...")
-            self.stream.writeln("------------------------------------------------------------------")
-
-    ## Method called after the test case has been executed.
-    #  Run the default implementation and based on the set verbosity level write
-    #  the result string to the output stream.
-    #  @param self The object pointer.
-    #  @param test Object variable to store the test case instance.
+            self.stream.writeln(
+                "Starting " + self.getDescription(test) + " ...")
+            self.stream.writeln(single_line_delim)
+
     def stopTest(self, test):
+        """
+        Stop a test
+
+        :param test:
+
+        """
         unittest.TestResult.stopTest(self, test)
         if self.verbosity > 0:
-            self.stream.writeln("------------------------------------------------------------------")
-            self.stream.writeln("%-60s%s" % (self.getDescription(test), self.result_string))
-            self.stream.writeln("------------------------------------------------------------------")
+            self.stream.writeln(single_line_delim)
+            self.stream.writeln("%-60s%s" %
+                                (self.getDescription(test), self.result_string))
+            self.stream.writeln(single_line_delim)
         else:
-            self.stream.writeln("%-60s%s" % (self.getDescription(test), self.result_string))
+            self.stream.writeln("%-60s%s" %
+                                (self.getDescription(test), self.result_string))
 
-    ## Method to write errors and failures information to the output stream.
-    #  Write content of errors and failures lists to the output stream.
-    #  @param self The object pointer.
     def printErrors(self):
+        """
+        Print errors from running the test case
+        """
         self.stream.writeln()
         self.printErrorList('ERROR', self.errors)
         self.printErrorList('FAIL', self.failures)
-        ## @var errors
-        #  List variable containing 2-tuples of TestCase instances and strings
-        #  holding formatted tracebacks. Each tuple represents a test which
-        #  raised an unexpected exception.
-        ## @var failures
-        #  List variable containing 2-tuples of TestCase instances and strings
-        #  holding formatted tracebacks. Each tuple represents a test where
-        #  a failure was explicitly signalled using the TestCase.assert*()
-        #  methods.
-
-    ## Method to write the error information to the output stream.
-    #  Write content of error lists to the output stream together with error
-    #  type and test case description.
-    #  @param self The object pointer.
-    #  @param flavour String variable to store error type.
-    #  @param errors List variable to store 2-tuples of TestCase instances and
-    #  strings holding formatted tracebacks.
+
     def printErrorList(self, flavour, errors):
+        """
+        Print error list to the output stream together with error type
+        and test case description.
+
+        :param flavour: error type
+        :param errors: iterable errors
+
+        """
         for test, err in errors:
-            self.stream.writeln('=' * 70)
-            self.stream.writeln("%s: %s" % (flavour, self.getDescription(test)))
-            self.stream.writeln('-' * 70)
+            self.stream.writeln(double_line_delim)
+            self.stream.writeln("%s: %s" %
+                                (flavour, self.getDescription(test)))
+            self.stream.writeln(single_line_delim)
             self.stream.writeln("%s" % err)
-        ## @var test
-        #  Object variable to store the test case instance.
-        ## @var err
-        #  String variable to store formatted tracebacks.
 
 
-## Subclass of the python unittest.TextTestRunner class.
-#
-#  A basic test runner implementation which prints results on standard error.
 class VppTestRunner(unittest.TextTestRunner):
-    ##  Class object variable to store the results of a set of tests.
-    resultclass = VppTestResult
-
-    ## Method to run the test.
-    #  Print debug message in the terminal and run the standard run() method
-    #  of the test runner collecting the result into the test result object.
-    #  @param self The object pointer.
-    #  @param test Object variable to store the test case instance.
-    #  @return Test result object of the VppTestRunner.
+    """
+    A basic test runner implementation which prints results on standard error.
+    """
+    @property
+    def resultclass(self):
+        """Class maintaining the results of the tests"""
+        return VppTestResult
+
     def run(self, test):
-        print "Running tests using custom test runner"  # debug message
+        """
+        Run the tests
+
+        :param test:
+
+        """
+        print("Running tests using custom test runner")  # debug message
         return super(VppTestRunner, self).run(test)