#!/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:
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)
Code Review / vpp.git / blobdiff