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>

20 files changed, 2658 insertions, 1867 deletions

diff --git a/Makefile b/Makefile
index 93277bec..54b0f29d 100644
--- a/Makefile
+++ b/Makefile
@@ -188,37 +188,36 @@ plugins-release: $(BR)/.bootstrap.ok
 build-vpp-api: $(BR)/.bootstrap.ok
 	$(call make,$(PLATFORM)_debug,vpp-api-install)
 
+PYTHON_PATH=$(BR)/python
+
 define test
-	@make -C test \
-	  VPP_TEST_BIN=$(BR)/install-$(1)-native/vpp/bin/vpp \
-	  VPP_TEST_API_TEST_BIN=$(BR)/install-$(1)-native/vpp-api-test/bin/vpp_api_test \
-	  VPP_TEST_PLUGIN_PATH=$(BR)/install-$(1)-native/plugins/lib64/vpp_plugins \
-	  V=$(V) TEST=$(TEST)
+	$(if $(filter-out $(3),retest),make -C $(BR) PLATFORM=$(1) TAG=$(2) vpp-api-install plugins-install vpp-install vpp-api-test-install,)
+	make -C test \
+	  VPP_TEST_BIN=$(BR)/install-$(2)-native/vpp/bin/vpp \
+	  VPP_TEST_API_TEST_BIN=$(BR)/install-$(2)-native/vpp-api-test/bin/vpp_api_test \
+	  VPP_TEST_PLUGIN_PATH=$(BR)/install-$(2)-native/plugins/lib64/vpp_plugins \
+	  LD_LIBRARY_PATH=$(BR)/install-$(2)-native/vpp-api/lib64/ \
+	  WS_ROOT=$(WS_ROOT) I=$(I) V=$(V) TEST=$(TEST) PYTHON_PATH=$(PYTHON_PATH) $(3)
 endef
 
 test: bootstrap
-ifeq ($(OS_ID),ubuntu)
-	@if ! (dpkg -l python-dev python-scapy &> /dev/null); then \
-	  sudo -E apt-get $(CONFIRM) $(FORCE) install python-dev python-scapy; \
-	fi
-endif
-	@make -C $(BR) PLATFORM=vpp_lite TAG=vpp_lite vpp-api-install plugins-install vpp-install vpp-api-test-install
-	$(call test,vpp_lite)
+	$(call test,vpp_lite,vpp_lite,test)
 
 test-debug: bootstrap
-ifeq ($(OS_ID),ubuntu)
-	@if ! (dpkg -l python-dev python-scapy &> /dev/null); then \
-	  sudo -E apt-get $(CONFIRM) $(FORCE) install python-dev python-scapy; \
-	fi
-endif
-	@make -C $(BR) PLATFORM=vpp_lite TAG=vpp_lite_debug vpp-api-install plugins-install vpp-install vpp-api-test-install
-	$(call test,vpp_lite_debug)
+	$(call test,vpp_lite,vpp_lite_debug,test)
+
+test-doc:
+	make -C $(BR) PLATFORM=vpp_lite TAG=vpp_lite vpp-api-install plugins-install vpp-install vpp-api-test-install
+	make -C test PYTHON_PATH=$(PYTHON_PATH) LD_LIBRARY_PATH=$(BR)/install-vpp_lite-native/vpp-api/lib64/ doc
+
+test-clean:
+	make -C test clean
 
 retest:
-	$(call test,vpp_lite)
+	$(call test,vpp_lite,vpp_lite,retest)
 
 retest-debug:
-	$(call test,vpp_lite_debug)
+	$(call test,vpp_lite,vpp_lite_debug,retest)
 
 STARTUP_DIR ?= $(PWD)
 ifeq ("$(wildcard $(STARTUP_CONF))","")
diff --git a/build-root/Makefile b/build-root/Makefile
index 97fb43d4..6e26e90e 100644
--- a/build-root/Makefile
+++ b/build-root/Makefile
@@ -1164,6 +1164,7 @@ distclean:
 	rm -rf $(MU_BUILD_ROOT_DIR)/*.deb
 	rm -rf $(MU_BUILD_ROOT_DIR)/*.rpm
 	rm -rf $(MU_BUILD_ROOT_DIR)/*.changes
+	rm -rf $(MU_BUILD_ROOT_DIR)/python
 	if [ -e /usr/bin/dh ];then (cd $(MU_BUILD_ROOT_DIR)/deb/;debian/rules clean); fi
 	rm -f $(MU_BUILD_ROOT_DIR)/deb/debian/*.install
 	rm -f $(MU_BUILD_ROOT_DIR)/deb/debian/*.dkms
diff --git a/test/Makefile b/test/Makefile
index 7cbcf97a..c90679e8 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -1,3 +1,22 @@
+PYTHON_VENV_PATH=$(PYTHON_PATH)/virtualenv
 
-all:
-	@python run_tests.py discover -p test_$(TEST)"*.py"
+test: clean
+	@virtualenv $(PYTHON_VENV_PATH)
+	@bash -c "source $(PYTHON_VENV_PATH)/bin/activate && pip install scapy"
+	@bash -c "source $(PYTHON_VENV_PATH)/bin/activate && pip install pexpect"
+	@bash -c "source $(PYTHON_VENV_PATH)/bin/activate && cd $(WS_ROOT)/vpp-api/python && python setup.py install"
+	@bash -c "source $(PYTHON_VENV_PATH)/bin/activate && python run_tests.py discover -p test_$(TEST)\"*.py\""
+
+retest: clean
+	@bash -c "source $(PYTHON_VENV_PATH)/bin/activate && python run_tests.py discover -p test_$(TEST)\"*.py\""
+
+.PHONY: clean doc
+
+clean:
+	@rm -f /dev/shm/vpp-unittest-*
+	@rm -rf /tmp/vpp-unittest-*
+
+doc:
+	@virtualenv $(PYTHON_VENV_PATH)
+	@bash -c "source $(PYTHON_VENV_PATH)/bin/activate && pip install sphinx"
+	@bash -c "source $(PYTHON_VENV_PATH)/bin/activate && make -C doc html"
diff --git a/test/doc/Makefile b/test/doc/Makefile
new file mode 100644
index 00000000..00655389
--- /dev/null
+++ b/test/doc/Makefile
@@ -0,0 +1,229 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+PAPER         =
+BUILDDIR      = _build
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+# the i18n builder cannot share the environment and doctrees with the others
+I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+
+.PHONY: regen-api-doc
+regen-api-doc:
+	sphinx-apidoc -o . ..
+
+.PHONY: help
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html       to make standalone HTML files"
+	@echo "  dirhtml    to make HTML files named index.html in directories"
+	@echo "  singlehtml to make a single large HTML file"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  applehelp  to make an Apple Help Book"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  epub3      to make an epub3"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  texinfo    to make Texinfo files"
+	@echo "  info       to make Texinfo files and run them through makeinfo"
+	@echo "  gettext    to make PO message catalogs"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  xml        to make Docutils-native XML files"
+	@echo "  pseudoxml  to make pseudoxml-XML files for display purposes"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+	@echo "  coverage   to run coverage check of the documentation (if enabled)"
+	@echo "  dummy      to check syntax errors of document sources"
+
+.PHONY: clean
+clean:
+	rm -rf $(BUILDDIR)/*
+
+.PHONY: html
+html: regen-api-doc
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+.PHONY: dirhtml
+dirhtml: regen-api-doc
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+.PHONY: singlehtml
+singlehtml: regen-api-doc
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
+	@echo
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
+
+.PHONY: pickle
+pickle: regen-api-doc
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+.PHONY: json
+json: regen-api-doc
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+.PHONY: htmlhelp
+htmlhelp: regen-api-doc
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+.PHONY: qthelp
+qthelp: regen-api-doc
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/VPPtestframework.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/VPPtestframework.qhc"
+
+.PHONY: applehelp
+applehelp: regen-api-doc
+	$(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp
+	@echo
+	@echo "Build finished. The help book is in $(BUILDDIR)/applehelp."
+	@echo "N.B. You won't be able to view it unless you put it in" \
+	      "~/Library/Documentation/Help or install it in your application" \
+	      "bundle."
+
+.PHONY: devhelp
+devhelp: regen-api-doc
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+	@echo
+	@echo "Build finished."
+	@echo "To view the help file:"
+	@echo "# mkdir -p $$HOME/.local/share/devhelp/VPPtestframework"
+	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/VPPtestframework"
+	@echo "# devhelp"
+
+.PHONY: epub
+epub: regen-api-doc
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+	@echo
+	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+.PHONY: epub3
+epub3:
+	$(SPHINXBUILD) -b epub3 $(ALLSPHINXOPTS) $(BUILDDIR)/epub3
+	@echo
+	@echo "Build finished. The epub3 file is in $(BUILDDIR)/epub3."
+
+.PHONY: latex
+latex: regen-api-doc
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make' in that directory to run these through (pdf)latex" \
+	      "(use \`make latexpdf' here to do that automatically)."
+
+.PHONY: latexpdf
+latexpdf: regen-api-doc
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+.PHONY: latexpdfja
+latexpdfja: regen-api-doc
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through platex and dvipdfmx..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+.PHONY: text
+text: regen-api-doc
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+	@echo
+	@echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+.PHONY: man
+man: regen-api-doc
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+	@echo
+	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+.PHONY: texinfo
+texinfo: regen-api-doc
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo
+	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
+	@echo "Run \`make' in that directory to run these through makeinfo" \
+	      "(use \`make info' here to do that automatically)."
+
+.PHONY: info
+info: regen-api-doc
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo "Running Texinfo files through makeinfo..."
+	make -C $(BUILDDIR)/texinfo info
+	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
+
+.PHONY: gettext
+gettext: regen-api-doc
+	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
+	@echo
+	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
+
+.PHONY: changes
+changes: regen-api-doc
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+.PHONY: linkcheck
+linkcheck: regen-api-doc
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+.PHONY: doctest
+doctest: regen-api-doc
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."
+
+.PHONY: coverage
+coverage: regen-api-doc
+	$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
+	@echo "Testing of coverage in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/coverage/python.txt."
+
+.PHONY: xml
+xml: regen-api-doc
+	$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
+	@echo
+	@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
+
+.PHONY: pseudoxml
+pseudoxml: regen-api-doc
+	$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
+	@echo
+	@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
+
+.PHONY: dummy
+dummy: regen-api-doc
+	$(SPHINXBUILD) -b dummy $(ALLSPHINXOPTS) $(BUILDDIR)/dummy
+	@echo
+	@echo "Build finished. Dummy builder generates no files."
diff --git a/test/doc/conf.py b/test/doc/conf.py
new file mode 100644
index 00000000..aa841714
--- /dev/null
+++ b/test/doc/conf.py
@@ -0,0 +1,340 @@
+# -*- coding: utf-8 -*-
+#
+# VPP test framework documentation build configuration file, created by
+# sphinx-quickstart on Thu Oct 13 08:45:03 2016.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import sys
+sys.path.insert(0, os.path.abspath('..'))
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#
+# needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc',
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+# source_suffix = ['.rst', '.md']
+source_suffix = '.rst'
+
+# The encoding of source files.
+#
+# source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = u'VPP test framework'
+copyright = u'2016, VPP team'
+author = u'VPP team'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = u'0.1'
+# The full version, including alpha/beta/rc tags.
+release = u'0.1'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#
+# today = ''
+#
+# Else, today_fmt is used as the format for a strftime call.
+#
+# today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This patterns also effect to html_static_path and html_extra_path
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+# The reST default role (used for this markup: `text`) to use for all
+# documents.
+#
+# default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#
+# add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#
+# add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#
+# show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# A list of ignored prefixes for module index sorting.
+# modindex_common_prefix = []
+
+# If true, keep warnings as "system message" paragraphs in the built documents.
+# keep_warnings = False
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = False
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'alabaster'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#
+# html_theme_options = {}
+
+# Add any paths that contain custom themes here, relative to this directory.
+# html_theme_path = []
+
+# The name for this set of Sphinx documents.
+# "<project> v<release> documentation" by default.
+#
+# html_title = u'VPP test framework v0.1'
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+#
+# html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+#
+# html_logo = None
+
+# The name of an image file (relative to this directory) to use as a favicon of
+# the docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#
+# html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+# Add any extra paths that contain custom files (such as robots.txt or
+# .htaccess) here, relative to this directory. These files are copied
+# directly to the root of the documentation.
+#
+# html_extra_path = []
+
+# If not None, a 'Last updated on:' timestamp is inserted at every page
+# bottom, using the given strftime format.
+# The empty string is equivalent to '%b %d, %Y'.
+#
+# html_last_updated_fmt = None
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#
+# html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+#
+# html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#
+# html_additional_pages = {}
+
+# If false, no module index is generated.
+#
+# html_domain_indices = True
+
+# If false, no index is generated.
+#
+# html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#
+# html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+#
+# html_show_sourcelink = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+#
+# html_show_sphinx = True
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+#
+# html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+#
+# html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+# html_file_suffix = None
+
+# Language to be used for generating the HTML full-text search index.
+# Sphinx supports the following languages:
+#   'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
+#   'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr', 'zh'
+#
+# html_search_language = 'en'
+
+# A dictionary with options for the search language support, empty by default.
+# 'ja' uses this config value.
+# 'zh' user can custom change `jieba` dictionary path.
+#
+# html_search_options = {'type': 'default'}
+
+# The name of a javascript file (relative to the configuration directory) that
+# implements a search results scorer. If empty, the default will be used.
+#
+# html_search_scorer = 'scorer.js'
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'VPPtestframeworkdoc'
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+     # The paper size ('letterpaper' or 'a4paper').
+     #
+     # 'papersize': 'letterpaper',
+
+     # The font size ('10pt', '11pt' or '12pt').
+     #
+     # 'pointsize': '10pt',
+
+     # Additional stuff for the LaTeX preamble.
+     #
+     # 'preamble': '',
+
+     # Latex figure (float) alignment
+     #
+     # 'figure_align': 'htbp',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+    (master_doc, 'VPPtestframework.tex', u'VPP test framework Documentation',
+     u'VPP team', 'manual'),
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+#
+# latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+#
+# latex_use_parts = False
+
+# If true, show page references after internal links.
+#
+# latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+#
+# latex_show_urls = False
+
+# Documents to append as an appendix to all manuals.
+#
+# latex_appendices = []
+
+# It false, will not define \strong, \code, 	itleref, \crossref ... but only
+# \sphinxstrong, ..., \sphinxtitleref, ... To help avoid clash with user added
+# packages.
+#
+# latex_keep_old_macro_names = True
+
+# If false, no module index is generated.
+#
+# latex_domain_indices = True
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    (master_doc, 'vpptestframework', u'VPP test framework Documentation',
+     [author], 1)
+]
+
+# If true, show URL addresses after external links.
+#
+# man_show_urls = False
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    (master_doc, 'VPPtestframework', u'VPP test framework Documentation',
+     author, 'VPPtestframework', 'One line description of project.',
+     'Miscellaneous'),
+]
+
+# Documents to append as an appendix to all manuals.
+#
+# texinfo_appendices = []
+
+# If false, no module index is generated.
+#
+# texinfo_domain_indices = True
+
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+#
+# texinfo_show_urls = 'footnote'
+
+# If true, do not generate a @detailmenu in the "Top" node's menu.
+#
+# texinfo_no_detailmenu = False
diff --git a/test/doc/index.rst b/test/doc/index.rst
new file mode 100644
index 00000000..c18357a4
--- /dev/null
+++ b/test/doc/index.rst
@@ -0,0 +1,22 @@
+.. VPP test framework documentation master file, created by
+   sphinx-quickstart on Thu Oct 13 08:45:03 2016.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Welcome to VPP test framework's documentation!
+==============================================
+
+Contents:
+
+.. toctree::
+   :maxdepth: 2
+
+   modules.rst
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
+
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)
diff --git a/test/hook.py b/test/hook.py
new file mode 100644
index 00000000..9489aa9d
--- /dev/null
+++ b/test/hook.py
@@ -0,0 +1,128 @@
+import signal
+import os
+import pexpect
+from logging import *
+
+
+class Hook(object):
+    """
+    Generic hooks before/after API/CLI calls
+    """
+
+    def before_api(self, api_name, api_args):
+        """
+        Function called before API call
+        Emit a debug message describing the API name and arguments
+
+        @param api_name: name of the API
+        @param api_args: tuple containing the API arguments
+        """
+        debug("API: %s (%s)" % (api_name, api_args))
+
+    def after_api(self, api_name, api_args):
+        """
+        Function called after API call
+
+        @param api_name: name of the API
+        @param api_args: tuple containing the API arguments
+        """
+        pass
+
+    def before_cli(self, cli):
+        """
+        Function called before CLI call
+        Emit a debug message describing the CLI
+
+        @param cli: CLI string
+        """
+        debug("CLI: %s" % (cli))
+
+    def after_cli(self, cli):
+        """
+        Function called after CLI call
+        """
+        pass
+
+
+class VppDiedError(Exception):
+    pass
+
+
+class PollHook(Hook):
+    """ Hook which checks if the vpp subprocess is alive """
+
+    def __init__(self, testcase):
+        self.vpp_dead = False
+        self.testcase = testcase
+
+    def spawn_gdb(self, gdb_path, core_path):
+        gdb_cmdline = gdb_path + ' ' + self.testcase.vpp_bin + ' ' + core_path
+        gdb = pexpect.spawn(gdb_cmdline)
+        gdb.interact()
+        try:
+            gdb.terminate(True)
+        except:
+            pass
+        if gdb.isalive():
+            raise Exception("GDB refused to die...")
+
+    def on_crash(self, core_path):
+        if self.testcase.interactive:
+            gdb_path = '/usr/bin/gdb'
+            if os.path.isfile(gdb_path) and os.access(gdb_path, os.X_OK):
+                # automatically attach gdb
+                self.spawn_gdb(gdb_path, core_path)
+                return
+            else:
+                error("Debugger '%s' does not exist or is not an executable.." %
+                      gdb_path)
+
+        critical('core file present, debug with: gdb ' +
+                 self.testcase.vpp_bin + ' ' + core_path)
+
+    def poll_vpp(self):
+        """
+        Poll the vpp status and throw an exception if it's not running
+        :raises VppDiedError: exception if VPP is not running anymore
+        """
+        if self.vpp_dead:
+            # already dead, nothing to do
+            return
+
+        self.testcase.vpp.poll()
+        if self.testcase.vpp.returncode is not None:
+            signaldict = dict(
+                (k, v) for v, k in reversed(sorted(signal.__dict__.items()))
+                if v.startswith('SIG') and not v.startswith('SIG_'))
+            msg = "VPP subprocess died unexpectedly with returncode %d [%s]" % (
+                self.testcase.vpp.returncode,
+                signaldict[abs(self.testcase.vpp.returncode)])
+            critical(msg)
+            core_path = self.testcase.tempdir + '/core'
+            if os.path.isfile(core_path):
+                self.on_crash(core_path)
+            self.testcase.vpp_dead = True
+            raise VppDiedError(msg)
+
+    def after_api(self, api_name, api_args):
+        """
+        Check if VPP died after executing an API
+
+        :param api_name: name of the API
+        :param api_args: tuple containing the API arguments
+        :raises VppDiedError: exception if VPP is not running anymore
+
+        """
+        super(PollHook, self).after_api(api_name, api_args)
+        self.poll_vpp()
+
+    def after_cli(self, cli):
+        """
+        Check if VPP died after executing a CLI
+
+        :param cli: CLI string
+        :raises Exception: exception if VPP is not running anymore
+
+        """
+        super(PollHook, self).after_cli(cli)
+        self.poll_vpp()
diff --git a/test/template_bd.py b/test/template_bd.py
index 473c4228..6c6fb3da 100644
--- a/test/template_bd.py
+++ b/test/template_bd.py
@@ -7,100 +7,94 @@ from scapy.layers.inet import IP, UDP
 
 
 class BridgeDomain(object):
-    def __init__(self):
-        ## Ethernet frame which is send to pg0 interface and is forwarded to pg1
-        self.payload_0_1 = (
-            Ether(src='00:00:00:00:00:01', dst='00:00:00:00:00:02') /
-            IP(src='1.2.3.4', dst='4.3.2.1') /
-            UDP(sport=10000, dport=20000) /
-            Raw('\xa5' * 100))
-
-        ## Ethernet frame which is send to pg1 interface and is forwarded to pg0
-        self.payload_1_0 = (
-            Ether(src='00:00:00:00:00:02', dst='00:00:00:00:00:01') /
-            IP(src='4.3.2.1', dst='1.2.3.4') /
-            UDP(sport=20000, dport=10000) /
-            Raw('\xa5' * 100))
-
-    ## Test case must implement this method, so template known how to send
-    #  encapsulated frame.
+    """ Bridge domain abstraction """
+
+    @property
+    def frame_pg0_to_pg1(self):
+        """ Ethernet frame sent from pg0 and expected to arrive at pg1 """
+        return (Ether(src='00:00:00:00:00:01', dst='00:00:00:00:00:02') /
+                IP(src='1.2.3.4', dst='4.3.2.1') /
+                UDP(sport=10000, dport=20000) /
+                Raw('\xa5' * 100))
+
+    @property
+    def frame_pg1_to_pg0(self):
+        """ Ethernet frame sent from pg1 and expected to arrive at pg0 """
+        return (Ether(src='00:00:00:00:00:02', dst='00:00:00:00:00:01') /
+                IP(src='4.3.2.1', dst='1.2.3.4') /
+                UDP(sport=20000, dport=10000) /
+                Raw('\xa5' * 100))
+
     @abstractmethod
     def encapsulate(self, pkt):
+        """ Encapsulate packet """
         pass
 
-    ## Test case must implement this method, so template known how to get
-    #  original payload.
     @abstractmethod
     def decapsulate(self, pkt):
+        """ Decapsulate packet """
         pass
 
-    ## Test case must implement this method, so template known how if the
-    #  received frame is corectly encapsulated.
     @abstractmethod
     def check_encapsulation(self, pkt):
+        """ Verify the encapsulation """
         pass
 
-    ## On pg0 interface are encapsulated frames, on pg1 are testing frames
-    #  without encapsulation
     def test_decap(self):
-        ## Prepare Ethernet frame that will be send encapsulated.
-        pkt_to_send = self.encapsulate(self.payload_0_1)
+        """ Decapsulation test
+        Send encapsulated frames from pg0
+        Verify receipt of decapsulated frames on pg1
+        """
+
+        encapsulated_pkt = self.encapsulate(self.frame_pg0_to_pg1)
 
-        ## Add packet to list of packets.
-        self.pg_add_stream(0, [pkt_to_send, ])
+        self.pg0.add_stream([encapsulated_pkt, ])
 
-        ## Enable Packet Capture on both ports.
-        self.pg_enable_capture([0, 1])
+        self.pg1.enable_capture()
 
-        ## Start all streams
         self.pg_start()
 
-        ## Pick first received frame and check if is same as non-encapsulated
-        #  frame.
-        out = self.pg_get_capture(1)
+        # Pick first received frame and check if it's the non-encapsulated frame
+        out = self.pg1.get_capture()
         self.assertEqual(len(out), 1,
                          'Invalid number of packets on '
                          'output: {}'.format(len(out)))
         pkt = out[0]
 
         # TODO: add error messages
-        self.assertEqual(pkt[Ether].src, self.payload_0_1[Ether].src)
-        self.assertEqual(pkt[Ether].dst, self.payload_0_1[Ether].dst)
-        self.assertEqual(pkt[IP].src, self.payload_0_1[IP].src)
-        self.assertEqual(pkt[IP].dst, self.payload_0_1[IP].dst)
-        self.assertEqual(pkt[UDP].sport, self.payload_0_1[UDP].sport)
-        self.assertEqual(pkt[UDP].dport, self.payload_0_1[UDP].dport)
-        self.assertEqual(pkt[Raw], self.payload_0_1[Raw])
-
-    ## Send non-encapsulated Ethernet frame from pg1 interface and expect
-    #  encapsulated frame on pg0. On pg0 interface are encapsulated frames,
-    #  on pg1 are testing frames without encapsulation.
+        self.assertEqual(pkt[Ether].src, self.frame_pg0_to_pg1[Ether].src)
+        self.assertEqual(pkt[Ether].dst, self.frame_pg0_to_pg1[Ether].dst)
+        self.assertEqual(pkt[IP].src, self.frame_pg0_to_pg1[IP].src)
+        self.assertEqual(pkt[IP].dst, self.frame_pg0_to_pg1[IP].dst)
+        self.assertEqual(pkt[UDP].sport, self.frame_pg0_to_pg1[UDP].sport)
+        self.assertEqual(pkt[UDP].dport, self.frame_pg0_to_pg1[UDP].dport)
+        self.assertEqual(pkt[Raw], self.frame_pg0_to_pg1[Raw])
+
     def test_encap(self):
-        ## Create packet generator stream.
-        self.pg_add_stream(1, [self.payload_1_0])
+        """ Encapsulation test
+        Send frames from pg1
+        Verify receipt of encapsulated frames on pg0
+        """
+        self.pg1.add_stream([self.frame_pg1_to_pg0])
 
-        ## Enable Packet Capture on both ports.
-        self.pg_enable_capture([0, 1])
+        self.pg0.enable_capture()
 
-        ## Start all streams.
         self.pg_start()
 
-        ## Pick first received frame and check if is corectly encapsulated.
-        out = self.pg_get_capture(0)
+        # Pick first received frame and check if it's corectly encapsulated.
+        out = self.pg0.get_capture()
         self.assertEqual(len(out), 1,
                          'Invalid number of packets on '
                          'output: {}'.format(len(out)))
-        rcvd = out[0]
-        self.check_encapsulation(rcvd)
+        pkt = out[0]
+        self.check_encapsulation(pkt)
 
-        ## Get original frame from received packet and check if is same as
-        #  sended frame.
-        rcvd_payload = self.decapsulate(rcvd)
+        payload = self.decapsulate(pkt)
         # TODO: add error messages
-        self.assertEqual(rcvd_payload[Ether].src, self.payload_1_0[Ether].src)
-        self.assertEqual(rcvd_payload[Ether].dst, self.payload_1_0[Ether].dst)
-        self.assertEqual(rcvd_payload[IP].src, self.payload_1_0[IP].src)
-        self.assertEqual(rcvd_payload[IP].dst, self.payload_1_0[IP].dst)
-        self.assertEqual(rcvd_payload[UDP].sport, self.payload_1_0[UDP].sport)
-        self.assertEqual(rcvd_payload[UDP].dport, self.payload_1_0[UDP].dport)
-        self.assertEqual(rcvd_payload[Raw], self.payload_1_0[Raw])
+        self.assertEqual(payload[Ether].src, self.frame_pg1_to_pg0[Ether].src)
+        self.assertEqual(payload[Ether].dst, self.frame_pg1_to_pg0[Ether].dst)
+        self.assertEqual(payload[IP].src, self.frame_pg1_to_pg0[IP].src)
+        self.assertEqual(payload[IP].dst, self.frame_pg1_to_pg0[IP].dst)
+        self.assertEqual(payload[UDP].sport, self.frame_pg1_to_pg0[UDP].sport)
+        self.assertEqual(payload[UDP].dport, self.frame_pg1_to_pg0[UDP].dport)
+        self.assertEqual(payload[Raw], self.frame_pg1_to_pg0[Raw])
diff --git a/test/test_ip.py b/test/test_ip.py
index 3a2c9011..48155a5a 100644
--- a/test/test_ip.py
+++ b/test/test_ip.py
@@ -1,230 +1,125 @@
 #!/usr/bin/env python
 
-import logging
-logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
-
 import unittest
+import socket
+from logging import *
+
 from framework import VppTestCase, VppTestRunner
-from util import Util
+from vpp_sub_interface import VppSubInterface, VppDot1QSubint, VppDot1ADSubint
 
 from scapy.packet import Raw
-from scapy.layers.l2 import Ether, ARP, Dot1Q
+from scapy.layers.l2 import Ether, Dot1Q, ARP
 from scapy.layers.inet import IP, UDP
 
 
-class TestIPv4(Util, VppTestCase):
+class TestIPv4(VppTestCase):
     """ IPv4 Test Case """
 
     @classmethod
     def setUpClass(cls):
         super(TestIPv4, cls).setUpClass()
 
-        try:
-            cls.create_interfaces_and_subinterfaces()
-
-            # configure IPv4 on hardware interfaces
-            cls.config_ip4(cls.interfaces)
-
-            cls.config_ip4_on_software_interfaces(cls.interfaces)
-
-            # resolve ARP using hardware interfaces
-            cls.resolve_arp(cls.interfaces)
-
-            # let VPP know MAC addresses of peer (sub)interfaces
-            cls.resolve_arp_on_software_interfaces(cls.interfaces)
-
-            # config 2M FIB enries
-            cls.config_fib_entries(2000000)
-
-        except Exception as e:
-            super(TestIPv4, cls).tearDownClass()
-            raise
-
-    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")  # 2M entries
-        self.cli(2, "show error")
-        self.cli(2, "show run")
-
-    @classmethod
-    def create_vlan_subif(cls, pg_index, vlan):
-        cls.api("create_vlan_subif pg%u vlan %u" % (pg_index, vlan))
-
-    @classmethod
-    def create_dot1ad_subif(cls, pg_index, sub_id, outer_vlan_id, inner_vlan_id):
-        cls.api("create_subif pg%u sub_id %u outer_vlan_id %u inner_vlan_id %u dot1ad"
-                 % (pg_index, sub_id, outer_vlan_id, inner_vlan_id))
-
-    class SoftInt(object):
-        pass
-
-    class HardInt(SoftInt):
-        pass
-
-    class Subint(SoftInt):
-        def __init__(self, sub_id):
-            self.sub_id = sub_id
-
-    class Dot1QSubint(Subint):
-        def __init__(self, sub_id, vlan=None):
-            if vlan is None:
-                vlan = sub_id
-            super(TestIPv4.Dot1QSubint, self).__init__(sub_id)
-            self.vlan = vlan
-
-    class Dot1ADSubint(Subint):
-        def __init__(self, sub_id, outer_vlan, inner_vlan):
-            super(TestIPv4.Dot1ADSubint, self).__init__(sub_id)
-            self.outer_vlan = outer_vlan
-            self.inner_vlan = inner_vlan
-
-    @classmethod
-    def create_interfaces_and_subinterfaces(cls):
-        cls.interfaces = range(3)
-
-        cls.create_interfaces(cls.interfaces)
+    def setUp(self):
+        super(TestIPv4, self).setUp()
 
-        # Make vpp_api_test see interfaces created using debug CLI (in function create_interfaces)
-        cls.api("sw_interface_dump")
+        # create 3 pg interfaces
+        self.create_pg_interfaces(range(3))
 
-        cls.INT_DETAILS = dict()
+        # create 2 subinterfaces for pg1 and pg2
+        self.sub_interfaces = [
+            VppDot1QSubint(self, self.pg1, 100),
+            VppDot1ADSubint(self, self.pg2, 200, 300, 400)]
 
-        cls.INT_DETAILS[0] = cls.HardInt()
+        # packet flows mapping pg0 -> pg1.sub, pg2.sub, etc.
+        self.flows = dict()
+        self.flows[self.pg0] = [self.pg1.sub_if, self.pg2.sub_if]
+        self.flows[self.pg1.sub_if] = [self.pg0, self.pg2.sub_if]
+        self.flows[self.pg2.sub_if] = [self.pg0, self.pg1.sub_if]
 
-        cls.INT_DETAILS[1] = cls.Dot1QSubint(100)
-        cls.create_vlan_subif(1, cls.INT_DETAILS[1].vlan)
+        # packet sizes
+        self.pg_if_packet_sizes = [64, 512, 1518, 9018]
+        self.sub_if_packet_sizes = [64, 512, 1518 + 4, 9018 + 4]
 
-        # FIXME: Wrong packet format/wrong layer on output of interface 2
-        #self.INT_DETAILS[2] = self.Dot1ADSubint(10, 200, 300)
-        #self.create_dot1ad_subif(2, self.INT_DETAILS[2].sub_id, self.INT_DETAILS[2].outer_vlan, self.INT_DETAILS[2].inner_vlan)
+        self.interfaces = list(self.pg_interfaces)
+        self.interfaces.extend(self.sub_interfaces)
 
-        # Use dor1q for now
-        cls.INT_DETAILS[2] = cls.Dot1QSubint(200)
-        cls.create_vlan_subif(2, cls.INT_DETAILS[2].vlan)
-
-        for i in cls.interfaces:
-            det = cls.INT_DETAILS[i]
-            if isinstance(det, cls.Subint):
-                cls.api("sw_interface_set_flags pg%u.%u admin-up" % (i, det.sub_id))
-
-    # IP adresses on subinterfaces
-    MY_SOFT_IP4S = {}
-    VPP_SOFT_IP4S = {}
-
-    @classmethod
-    def config_ip4_on_software_interfaces(cls, args):
-        for i in args:
-            cls.MY_SOFT_IP4S[i] = "172.17.%u.2" % i
-            cls.VPP_SOFT_IP4S[i] = "172.17.%u.1" % i
-            if isinstance(cls.INT_DETAILS[i], cls.Subint):
-                interface = "pg%u.%u" % (i, cls.INT_DETAILS[i].sub_id)
-            else:
-                interface = "pg%u" % i
-            cls.api("sw_interface_add_del_address %s %s/24" % (interface, cls.VPP_SOFT_IP4S[i]))
-            cls.log("My subinterface IPv4 address is %s" % (cls.MY_SOFT_IP4S[i]))
-
-    # let VPP know MAC addresses of peer (sub)interfaces
-    @classmethod
-    def resolve_arp_on_software_interfaces(cls, args):
-        for i in args:
-            ip = cls.VPP_SOFT_IP4S[i]
-            cls.log("Sending ARP request for %s on port %u" % (ip, i))
-            packet = (Ether(dst="ff:ff:ff:ff:ff:ff", src=cls.MY_MACS[i]) /
-                      ARP(op=ARP.who_has, pdst=ip, psrc=cls.MY_SOFT_IP4S[i], hwsrc=cls.MY_MACS[i]))
-
-            cls.add_dot1_layers(i, packet)
-
-            cls.pg_add_stream(i, packet)
-            cls.pg_enable_capture([i])
-
-            cls.cli(2, "trace add pg-input 1")
-            cls.pg_start()
-
-            # We don't need to read output
-
-    @classmethod
-    def config_fib_entries(cls, count):
-        n_int = len(cls.interfaces)
-        for i in cls.interfaces:
-            cls.api("ip_add_del_route 10.0.0.1/32 via %s count %u" % (cls.VPP_SOFT_IP4S[i], count / n_int))
-
-    @classmethod
-    def add_dot1_layers(cls, i, packet):
-        assert(type(packet) is Ether)
-        payload = packet.payload
-        det = cls.INT_DETAILS[i]
-        if isinstance(det, cls.Dot1QSubint):
-            packet.remove_payload()
-            packet.add_payload(Dot1Q(vlan=det.sub_id) / payload)
-        elif isinstance(det, cls.Dot1ADSubint):
-            packet.remove_payload()
-            packet.add_payload(Dot1Q(vlan=det.outer_vlan) / Dot1Q(vlan=det.inner_vlan) / payload)
-            packet.type = 0x88A8
+        # setup all interfaces
+        for i in self.interfaces:
+            i.admin_up()
+            i.config_ip4()
+            i.resolve_arp()
 
-    def remove_dot1_layers(self, i, packet):
-        self.assertEqual(type(packet), Ether)
-        payload = packet.payload
-        det = self.INT_DETAILS[i]
-        if isinstance(det, self.Dot1QSubint):
-            self.assertEqual(type(payload), Dot1Q)
-            self.assertEqual(payload.vlan, self.INT_DETAILS[i].vlan)
-            payload = payload.payload
-        elif isinstance(det, self.Dot1ADSubint):  # TODO: change 88A8 type
-            self.assertEqual(type(payload), Dot1Q)
-            self.assertEqual(payload.vlan, self.INT_DETAILS[i].outer_vlan)
-            payload = payload.payload
-            self.assertEqual(type(payload), Dot1Q)
-            self.assertEqual(payload.vlan, self.INT_DETAILS[i].inner_vlan)
-            payload = payload.payload
-        packet.remove_payload()
-        packet.add_payload(payload)
+        # config 2M FIB enries
+        self.config_fib_entries(200)
 
-    def create_stream(self, pg_id):
-        pg_targets = [None] * 3
-        pg_targets[0] = [1, 2]
-        pg_targets[1] = [0, 2]
-        pg_targets[2] = [0, 1]
+    def tearDown(self):
+        super(TestIPv4, self).tearDown()
+        if not self.vpp_dead:
+            info(self.vapi.cli("show ip arp"))
+            # info(self.vapi.cli("show ip fib"))  # many entries
+
+    def config_fib_entries(self, count):
+        n_int = len(self.interfaces)
+        percent = 0
+        counter = 0.0
+        dest_addr = socket.inet_pton(socket.AF_INET, "10.0.0.1")
+        dest_addr_len = 32
+        for i in self.interfaces:
+            next_hop_address = i.local_ip4n
+            for j in range(count / n_int):
+                self.vapi.ip_add_del_route(
+                    dest_addr, dest_addr_len, next_hop_address)
+                counter = counter + 1
+                if counter / count * 100 > percent:
+                    info("Configure %d FIB entries .. %d%% done" %
+                         (count, percent))
+                    percent = percent + 1
+
+    def create_stream(self, src_if, packet_sizes):
         pkts = []
         for i in range(0, 257):
-            target_pg_id = pg_targets[pg_id][i % 2]
-            info = self.create_packet_info(pg_id, target_pg_id)
+            dst_if = self.flows[src_if][i % 2]
+            info = self.create_packet_info(
+                src_if.sw_if_index, dst_if.sw_if_index)
             payload = self.info_to_payload(info)
-            p = (Ether(dst=self.VPP_MACS[pg_id], src=self.MY_MACS[pg_id]) /
-                 IP(src=self.MY_SOFT_IP4S[pg_id], dst=self.MY_SOFT_IP4S[target_pg_id]) /
+            p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
+                 IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4) /
                  UDP(sport=1234, dport=1234) /
                  Raw(payload))
             info.data = p.copy()
-            self.add_dot1_layers(pg_id, p)
-            if not isinstance(self.INT_DETAILS[pg_id], self.Subint):
-                packet_sizes = [64, 512, 1518, 9018]
-            else:
-                packet_sizes = [64, 512, 1518+4, 9018+4]
-            size = packet_sizes[(i / 2) % len(packet_sizes)]
+            if isinstance(src_if, VppSubInterface):
+                p = src_if.add_dot1_layer(p)
+            size = packet_sizes[(i // 2) % len(packet_sizes)]
             self.extend_packet(p, size)
             pkts.append(p)
         return pkts
 
-    def verify_capture(self, o, capture):
-        last_info = {}
+    def verify_capture(self, dst_if, capture):
+        info("Verifying capture on interface %s" % dst_if.name)
+        last_info = dict()
         for i in self.interfaces:
-            last_info[i] = None
+            last_info[i.sw_if_index] = None
+        is_sub_if = False
+        dst_sw_if_index = dst_if.sw_if_index
+        if hasattr(dst_if, 'parent'):
+            is_sub_if = True
         for packet in capture:
-            self.remove_dot1_layers(o, packet)  # Check VLAN tags and Ethernet header
+            if is_sub_if:
+                # Check VLAN tags and Ethernet header
+                packet = dst_if.remove_dot1_layer(packet)
             self.assertTrue(Dot1Q not in packet)
             try:
                 ip = packet[IP]
                 udp = packet[UDP]
                 payload_info = self.payload_to_info(str(packet[Raw]))
                 packet_index = payload_info.index
-                src_pg = payload_info.src
-                dst_pg = payload_info.dst
-                self.assertEqual(dst_pg, o)
-                self.log("Got packet on port %u: src=%u (id=%u)" % (o, src_pg, packet_index), 2)
-                next_info = self.get_next_packet_info_for_interface2(src_pg, dst_pg, last_info[src_pg])
-                last_info[src_pg] = next_info
+                self.assertEqual(payload_info.dst, dst_sw_if_index)
+                debug("Got packet on port %s: src=%u (id=%u)" %
+                      (dst_if.name, payload_info.src, packet_index))
+                next_info = self.get_next_packet_info_for_interface2(
+                    payload_info.src, dst_sw_if_index,
+                    last_info[payload_info.src])
+                last_info[payload_info.src] = next_info
                 self.assertTrue(next_info is not None)
                 self.assertEqual(packet_index, next_info.index)
                 saved_packet = next_info.data
@@ -234,28 +129,37 @@ class TestIPv4(Util, VppTestCase):
                 self.assertEqual(udp.sport, saved_packet[UDP].sport)
                 self.assertEqual(udp.dport, saved_packet[UDP].dport)
             except:
-                self.log("Unexpected or invalid packet:")
-                packet.show()
+                error("Unexpected or invalid packet:")
+                error(packet.show())
                 raise
         for i in self.interfaces:
-            remaining_packet = self.get_next_packet_info_for_interface2(i, o, last_info[i])
-            self.assertTrue(remaining_packet is None, "Port %u: Packet expected from source %u didn't arrive" % (o, i))
+            remaining_packet = self.get_next_packet_info_for_interface2(
+                i.sw_if_index, dst_sw_if_index, last_info[i.sw_if_index])
+            self.assertTrue(
+                remaining_packet is None,
+                "Interface %s: Packet expected from interface %s didn't arrive" %
+                (dst_if.name, i.name))
 
     def test_fib(self):
         """ IPv4 FIB test """
 
-        for i in self.interfaces:
-            pkts = self.create_stream(i)
-            self.pg_add_stream(i, pkts)
+        pkts = self.create_stream(self.pg0, self.pg_if_packet_sizes)
+        self.pg0.add_stream(pkts)
+
+        for i in self.sub_interfaces:
+            pkts = self.create_stream(i, self.sub_if_packet_sizes)
+            i.parent.add_stream(pkts)
 
-        self.pg_enable_capture(self.interfaces)
+        self.pg_enable_capture(self.pg_interfaces)
         self.pg_start()
 
-        for i in self.interfaces:
-            out = self.pg_get_capture(i)
-            self.log("Verifying capture %u" % i)
-            self.verify_capture(i, out)
+        pkts = self.pg0.get_capture()
+        self.verify_capture(self.pg0, pkts)
+
+        for i in self.sub_interfaces:
+            pkts = i.parent.get_capture()
+            self.verify_capture(i, pkts)
 
 
 if __name__ == '__main__':
-    unittest.main(testRunner = VppTestRunner)
+    unittest.main(testRunner=VppTestRunner)
diff --git a/test/test_ip6.py b/test/test_ip6.py
index 38808a9e..92bb350d 100644
--- a/test/test_ip6.py
+++ b/test/test_ip6.py
@@ -1,250 +1,126 @@
 #!/usr/bin/env python
 
-import logging
-logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
-
 import unittest
+import socket
+from logging import *
+
 from framework import VppTestCase, VppTestRunner
-from util import Util
+from vpp_sub_interface import VppSubInterface, VppDot1QSubint, VppDot1ADSubint
 
 from scapy.packet import Raw
 from scapy.layers.l2 import Ether, Dot1Q
-from scapy.layers.inet6 import (IPv6, UDP,
-    ICMPv6ND_NS, ICMPv6NDOptSrcLLAddr,
-    ICMPv6ND_NA, ICMPv6NDOptDstLLAddr)
+from scapy.layers.inet6 import ICMPv6ND_NS, IPv6, UDP
 
 
-@unittest.skip('Not finished yet.\n')
-class TestIPv6(Util, VppTestCase):
+class TestIPv6(VppTestCase):
     """ IPv6 Test Case """
 
     @classmethod
     def setUpClass(cls):
         super(TestIPv6, cls).setUpClass()
 
-        try:
-            cls.create_interfaces_and_subinterfaces()
-
-            # configure IPv6 on hardware interfaces
-            cls.config_ip6(cls.interfaces)
-
-            cls.config_ip6_on_software_interfaces(cls.interfaces)
-
-            # resolve ICMPv6 ND using hardware interfaces
-            cls.resolve_icmpv6_nd(cls.interfaces)
-
-            # let VPP know MAC addresses of peer (sub)interfaces
-            # cls.resolve_icmpv6_nd_on_software_interfaces(cls.interfaces)
-            cls.send_neighbour_advertisement_on_software_interfaces(cls.interfaces)
-
-            # config 2M FIB enries
-            #cls.config_fib_entries(2000000)
-            cls.config_fib_entries(1000000)
-
-        except Exception as e:
-            super(TestIPv6, cls).tearDownClass()
-            raise
-
-    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")  # 2M entries
-        self.cli(2, "show error")
-        self.cli(2, "show run")
-
-    @classmethod
-    def create_vlan_subif(cls, pg_index, vlan):
-        cls.api("create_vlan_subif pg%u vlan %u" % (pg_index, vlan))
-
-    @classmethod
-    def create_dot1ad_subif(cls, pg_index, sub_id, outer_vlan_id, inner_vlan_id):
-        cls.api("create_subif pg%u sub_id %u outer_vlan_id %u inner_vlan_id %u dot1ad"
-                 % (pg_index, sub_id, outer_vlan_id, inner_vlan_id))
-
-    class SoftInt(object):
-        pass
-
-    class HardInt(SoftInt):
-        pass
-
-    class Subint(SoftInt):
-        def __init__(self, sub_id):
-            self.sub_id = sub_id
-
-    class Dot1QSubint(Subint):
-        def __init__(self, sub_id, vlan=None):
-            if vlan is None:
-                vlan = sub_id
-            super(TestIPv6.Dot1QSubint, self).__init__(sub_id)
-            self.vlan = vlan
-
-    class Dot1ADSubint(Subint):
-        def __init__(self, sub_id, outer_vlan, inner_vlan):
-            super(TestIPv6.Dot1ADSubint, self).__init__(sub_id)
-            self.outer_vlan = outer_vlan
-            self.inner_vlan = inner_vlan
-
-    @classmethod
-    def create_interfaces_and_subinterfaces(cls):
-        cls.interfaces = range(3)
-
-        cls.create_interfaces(cls.interfaces)
+    def setUp(self):
+        super(TestIPv6, self).setUp()
 
-        # Make vpp_api_test see interfaces created using debug CLI (in function create_interfaces)
-        cls.api("sw_interface_dump")
+        # create 3 pg interfaces
+        self.create_pg_interfaces(range(3))
 
-        cls.INT_DETAILS = dict()
+        # create 2 subinterfaces for p1 and pg2
+        self.sub_interfaces = [
+            VppDot1QSubint(self, self.pg1, 100),
+            VppDot1QSubint(self, self.pg2, 200)]
+            # TODO: VppDot1ADSubint(self, self.pg2, 200, 300, 400)
 
-        cls.INT_DETAILS[0] = cls.HardInt()
+        # packet flows mapping pg0 -> pg1.sub, pg2.sub, etc.
+        self.flows = dict()
+        self.flows[self.pg0] = [self.pg1.sub_if, self.pg2.sub_if]
+        self.flows[self.pg1.sub_if] = [self.pg0, self.pg2.sub_if]
+        self.flows[self.pg2.sub_if] = [self.pg0, self.pg1.sub_if]
 
-        cls.INT_DETAILS[1] = cls.Dot1QSubint(100)
-        cls.create_vlan_subif(1, cls.INT_DETAILS[1].vlan)
+        # packet sizes
+        self.pg_if_packet_sizes = [64, 512, 1518, 9018]
+        self.sub_if_packet_sizes = [64, 512, 1518 + 4, 9018 + 4]
 
-        # FIXME: Wrong packet format/wrong layer on output of interface 2
-        #self.INT_DETAILS[2] = self.Dot1ADSubint(10, 200, 300)
-        #self.create_dot1ad_subif(2, self.INT_DETAILS[2].sub_id, self.INT_DETAILS[2].outer_vlan, self.INT_DETAILS[2].inner_vlan)
+        self.interfaces = list(self.pg_interfaces)
+        self.interfaces.extend(self.sub_interfaces)
 
-        # Use dor1q for now
-        cls.INT_DETAILS[2] = cls.Dot1QSubint(200)
-        cls.create_vlan_subif(2, cls.INT_DETAILS[2].vlan)
-
-        for i in cls.interfaces:
-            det = cls.INT_DETAILS[i]
-            if isinstance(det, cls.Subint):
-                cls.api("sw_interface_set_flags pg%u.%u admin-up" % (i, det.sub_id))
-
-    # IP adresses on subinterfaces
-    MY_SOFT_IP6S = {}
-    VPP_SOFT_IP6S = {}
-
-    @classmethod
-    def config_ip6_on_software_interfaces(cls, args):
-        for i in args:
-            cls.MY_SOFT_IP6S[i] = "fd01:%u::2" % i
-            cls.VPP_SOFT_IP6S[i] = "fd01:%u::1" % i
-            if isinstance(cls.INT_DETAILS[i], cls.Subint):
-                interface = "pg%u.%u" % (i, cls.INT_DETAILS[i].sub_id)
-            else:
-                interface = "pg%u" % i
-            cls.api("sw_interface_add_del_address %s %s/32" % (interface, cls.VPP_SOFT_IP6S[i]))
-            cls.log("My subinterface IPv6 address is %s" % (cls.MY_SOFT_IP6S[i]))
-
-    # let VPP know MAC addresses of peer (sub)interfaces
-    @classmethod
-    def resolve_icmpv6_nd_on_software_interfaces(cls, args):
-        for i in args:
-            ip = cls.VPP_SOFT_IP6S[i]
-            cls.log("Sending ICMPv6ND_NS request for %s on port %u" % (ip, i))
-            nd_req = (Ether(dst="ff:ff:ff:ff:ff:ff", src=cls.MY_MACS[i]) /
-                      IPv6(src=cls.MY_SOFT_IP6S[i], dst=ip) /
-                      ICMPv6ND_NS(tgt=ip) /
-                      ICMPv6NDOptSrcLLAddr(lladdr=cls.MY_MACS[i]))
-            cls.pg_add_stream(i, nd_req)
-            cls.pg_enable_capture([i])
-
-            cls.cli(2, "trace add pg-input 1")
-            cls.pg_start()
-
-            # We don't need to read output
-
-    # let VPP know MAC addresses of peer (sub)interfaces
-    @classmethod
-    def send_neighbour_advertisement_on_software_interfaces(cls, args):
-        for i in args:
-            ip = cls.VPP_SOFT_IP6S[i]
-            cls.log("Sending ICMPv6ND_NA message for %s on port %u" % (ip, i))
-            pkt = (Ether(dst="ff:ff:ff:ff:ff:ff", src=cls.MY_MACS[i]) /
-                   IPv6(src=cls.MY_SOFT_IP6S[i], dst=ip) /
-                   ICMPv6ND_NA(tgt=ip, R=0, S=0) /
-                   ICMPv6NDOptDstLLAddr(lladdr=cls.MY_MACS[i]))
-            cls.pg_add_stream(i, pkt)
-            cls.pg_enable_capture([i])
-
-            cls.cli(2, "trace add pg-input 1")
-            cls.pg_start()
-
-    @classmethod
-    def config_fib_entries(cls, count):
-        n_int = len(cls.interfaces)
-        for i in cls.interfaces:
-            cls.api("ip_add_del_route fd02::1/128 via %s count %u" % (cls.VPP_SOFT_IP6S[i], count / n_int))
-
-    @classmethod
-    def add_dot1_layers(cls, i, packet):
-        assert(type(packet) is Ether)
-        payload = packet.payload
-        det = cls.INT_DETAILS[i]
-        if isinstance(det, cls.Dot1QSubint):
-            packet.remove_payload()
-            packet.add_payload(Dot1Q(vlan=det.sub_id) / payload)
-        elif isinstance(det, cls.Dot1ADSubint):
-            packet.remove_payload()
-            packet.add_payload(Dot1Q(vlan=det.outer_vlan) / Dot1Q(vlan=det.inner_vlan) / payload)
-            packet.type = 0x88A8
+        # setup all interfaces
+        for i in self.interfaces:
+            i.admin_up()
+            i.config_ip6()
+            i.resolve_ndp()
 
-    def remove_dot1_layers(self, i, packet):
-        self.assertEqual(type(packet), Ether)
-        payload = packet.payload
-        det = self.INT_DETAILS[i]
-        if isinstance(det, self.Dot1QSubint):
-            self.assertEqual(type(payload), Dot1Q)
-            self.assertEqual(payload.vlan, self.INT_DETAILS[i].vlan)
-            payload = payload.payload
-        elif isinstance(det, self.Dot1ADSubint):  # TODO: change 88A8 type
-            self.assertEqual(type(payload), Dot1Q)
-            self.assertEqual(payload.vlan, self.INT_DETAILS[i].outer_vlan)
-            payload = payload.payload
-            self.assertEqual(type(payload), Dot1Q)
-            self.assertEqual(payload.vlan, self.INT_DETAILS[i].inner_vlan)
-            payload = payload.payload
-        packet.remove_payload()
-        packet.add_payload(payload)
+        # config 2M FIB enries
+        self.config_fib_entries(200)
 
-    def create_stream(self, pg_id):
-        pg_targets = [None] * 3
-        pg_targets[0] = [1, 2]
-        pg_targets[1] = [0, 2]
-        pg_targets[2] = [0, 1]
+    def tearDown(self):
+        super(TestIPv6, self).tearDown()
+        if not self.vpp_dead:
+            info(self.vapi.cli("show ip6 neighbors"))
+            # info(self.vapi.cli("show ip6 fib"))  # many entries
+
+    def config_fib_entries(self, count):
+        n_int = len(self.interfaces)
+        percent = 0
+        counter = 0.0
+        dest_addr = socket.inet_pton(socket.AF_INET6, "fd02::1")
+        dest_addr_len = 128
+        for i in self.interfaces:
+            next_hop_address = i.local_ip6n
+            for j in range(count / n_int):
+                self.vapi.ip_add_del_route(
+                    dest_addr, dest_addr_len, next_hop_address, is_ipv6=1)
+                counter = counter + 1
+                if counter / count * 100 > percent:
+                    info("Configure %d FIB entries .. %d%% done" %
+                         (count, percent))
+                    percent = percent + 1
+
+    def create_stream(self, src_if, packet_sizes):
         pkts = []
         for i in range(0, 257):
-            target_pg_id = pg_targets[pg_id][i % 2]
-            info = self.create_packet_info(pg_id, target_pg_id)
+            dst_if = self.flows[src_if][i % 2]
+            info = self.create_packet_info(
+                src_if.sw_if_index, dst_if.sw_if_index)
             payload = self.info_to_payload(info)
-            p = (Ether(dst=self.VPP_MACS[pg_id], src=self.MY_MACS[pg_id]) /
-                 IPv6(src=self.MY_SOFT_IP6S[pg_id], dst=self.MY_SOFT_IP6S[target_pg_id]) /
+            p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
+                 IPv6(src=src_if.remote_ip6, dst=dst_if.remote_ip6) /
                  UDP(sport=1234, dport=1234) /
                  Raw(payload))
             info.data = p.copy()
-            self.add_dot1_layers(pg_id, p)
-            if not isinstance(self.INT_DETAILS[pg_id], self.Subint):
-                packet_sizes = [76, 512, 1518, 9018]
-            else:
-                packet_sizes = [76, 512, 1518+4, 9018+4]
-            size = packet_sizes[(i / 2) % len(packet_sizes)]
+            if isinstance(src_if, VppSubInterface):
+                p = src_if.add_dot1_layer(p)
+            size = packet_sizes[(i // 2) % len(packet_sizes)]
             self.extend_packet(p, size)
             pkts.append(p)
         return pkts
 
-    def verify_capture(self, o, capture):
-        last_info = {}
+    def verify_capture(self, dst_if, capture):
+        info("Verifying capture on interface %s" % dst_if.name)
+        last_info = dict()
         for i in self.interfaces:
-            last_info[i] = None
+            last_info[i.sw_if_index] = None
+        is_sub_if = False
+        dst_sw_if_index = dst_if.sw_if_index
+        if hasattr(dst_if, 'parent'):
+            is_sub_if = True
         for packet in capture:
-            self.remove_dot1_layers(o, packet)  # Check VLAN tags and Ethernet header
+            if is_sub_if:
+                # Check VLAN tags and Ethernet header
+                packet = dst_if.remove_dot1_layer(packet)
             self.assertTrue(Dot1Q not in packet)
             try:
                 ip = packet[IPv6]
                 udp = packet[UDP]
                 payload_info = self.payload_to_info(str(packet[Raw]))
                 packet_index = payload_info.index
-                src_pg = payload_info.src
-                dst_pg = payload_info.dst
-                self.assertEqual(dst_pg, o)
-                self.log("Got packet on port %u: src=%u (id=%u)" % (o, src_pg, packet_index), 2)
-                next_info = self.get_next_packet_info_for_interface2(src_pg, dst_pg, last_info[src_pg])
-                last_info[src_pg] = next_info
+                self.assertEqual(payload_info.dst, dst_sw_if_index)
+                debug("Got packet on port %s: src=%u (id=%u)" %
+                      (dst_if.name, payload_info.src, packet_index))
+                next_info = self.get_next_packet_info_for_interface2(
+                    payload_info.src, dst_sw_if_index,
+                    last_info[payload_info.src])
+                last_info[payload_info.src] = next_info
                 self.assertTrue(next_info is not None)
                 self.assertEqual(packet_index, next_info.index)
                 saved_packet = next_info.data
@@ -254,28 +130,37 @@ class TestIPv6(Util, VppTestCase):
                 self.assertEqual(udp.sport, saved_packet[UDP].sport)
                 self.assertEqual(udp.dport, saved_packet[UDP].dport)
             except:
-                self.log("Unexpected or invalid packet:")
-                packet.show()
+                error("Unexpected or invalid packet:")
+                error(packet.show())
                 raise
         for i in self.interfaces:
-            remaining_packet = self.get_next_packet_info_for_interface2(i, o, last_info[i])
-            self.assertTrue(remaining_packet is None, "Port %u: Packet expected from source %u didn't arrive" % (o, i))
+            remaining_packet = self.get_next_packet_info_for_interface2(
+                i.sw_if_index, dst_sw_if_index, last_info[i.sw_if_index])
+            self.assertTrue(
+                remaining_packet is None,
+                "Interface %s: Packet expected from interface %s didn't arrive" %
+                (dst_if.name, i.name))
 
     def test_fib(self):
         """ IPv6 FIB test """
 
-        for i in self.interfaces:
-            pkts = self.create_stream(i)
-            self.pg_add_stream(i, pkts)
+        pkts = self.create_stream(self.pg0, self.pg_if_packet_sizes)
+        self.pg0.add_stream(pkts)
+
+        for i in self.sub_interfaces:
+            pkts = self.create_stream(i, self.sub_if_packet_sizes)
+            i.parent.add_stream(pkts)
 
-        self.pg_enable_capture(self.interfaces)
+        self.pg_enable_capture(self.pg_interfaces)
         self.pg_start()
 
-        for i in self.interfaces:
-            out = self.pg_get_capture(i)
-            self.log("Verifying capture %u" % i)
-            self.verify_capture(i, out)
+        pkts = self.pg0.get_capture()
+        self.verify_capture(self.pg0, pkts)
+
+        for i in self.sub_interfaces:
+            pkts = i.parent.get_capture()
+            self.verify_capture(i, pkts)
 
 
 if __name__ == '__main__':
-    unittest.main(testRunner = VppTestRunner)
+    unittest.main(testRunner=VppTestRunner)
diff --git a/test/test_l2bd.py b/test/test_l2bd.py
index c2b73a4d..0fced5d9 100644
--- a/test/test_l2bd.py
+++ b/test/test_l2bd.py
@@ -1,438 +1,187 @@
 #!/usr/bin/env python
-## @file test_l2bd.py
-#  Module to provide L2 bridge domain test case.
-#
-#  The module provides a set of tools for L2 bridge domain tests.
-
-import logging
-logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
 
 import unittest
+from logging import *
 import random
 
-from framework import *
-from scapy.all import *
+from scapy.packet import Raw
+from scapy.layers.l2 import Ether, Dot1Q
+from scapy.layers.inet import IP, UDP
+
+from framework import VppTestCase, VppTestRunner
+from vpp_sub_interface import VppDot1QSubint
+from util import TestHost
 
 
-## Subclass of the VppTestCase class.
-#
-#  This subclass is a class for L2 bridge domain test cases. It provides methods
-#  to create interfaces, configure L2 bridge domain, create and verify packet
-#  streams.
 class TestL2bd(VppTestCase):
     """ L2BD Test Case """
 
-    ## Test variables
-    interf_nr = 3           # Number of interfaces
-    bd_id = 1               # Bridge domain ID
-    mac_entries = 100       # Number of MAC entries for bridge-domain to learn
-    dot1q_sub_id = 100      # SubID of dot1q sub-interface
-    dot1q_tag = 100         # VLAN tag for dot1q sub-interface
-    dot1ad_sub_id = 200     # SubID of dot1ad sub-interface
-    dot1ad_outer_tag = 200  # VLAN S-tag for dot1ad sub-interface
-    dot1ad_inner_tag = 300  # VLAN C-tag for dot1ad sub-interface
-    pkts_per_burst = 257    # Number of packets per burst
+    # Test variables
+    bd_id = 1                 # Bridge domain ID
+    mac_entries_count = 100   # Number of MAC entries for bridge-domain to learn
+    dot1q_sub_id = 100        # SubID of dot1q sub-interface
+    dot1q_tag = 100           # VLAN tag for dot1q sub-interface
+    dot1ad_sub_id = 200       # SubID of dot1ad sub-interface
+    dot1ad_outer_tag = 200    # VLAN S-tag for dot1ad sub-interface
+    dot1ad_inner_tag = 300    # VLAN C-tag for dot1ad sub-interface
+    pkts_per_burst = 257      # Number of packets per burst
 
-    ## Class method to start the test case.
-    #  Overrides setUpClass method in VppTestCase class.
-    #  Python try..except statement is used to ensure that the tear down of
-    #  the class will be executed even if exception is raised.
-    #  @param cls The class pointer.
     @classmethod
     def setUpClass(cls):
         super(TestL2bd, cls).setUpClass()
 
-        try:
-            ## Create interfaces and sub-interfaces
-            cls.create_interfaces_and_subinterfaces(TestL2bd.interf_nr)
-
-            ## Create BD with MAC learning enabled and put interfaces and
-            #  sub-interfaces to this BD
-            cls.api("bridge_domain_add_del bd_id %u learn 1" % TestL2bd.bd_id)
-            for i in cls.interfaces:
-                if isinstance(cls.INT_DETAILS[i], cls.Subint):
-                    interface = "pg%u.%u" % (i, cls.INT_DETAILS[i].sub_id)
-                else:
-                    interface = "pg%u" % i
-                cls.api("sw_interface_set_l2_bridge %s bd_id %u"
-                        % (interface, TestL2bd.bd_id))
-
-            ## Make the BD learn a number of MAC entries specified by the test
-            # variable <mac_entries>.
-            cls.create_mac_entries(TestL2bd.mac_entries)
-            cls.cli(0, "show l2fib")
-
-        except Exception as e:
-          super(TestL2bd, cls).tearDownClass()
-          raise e
-
-    ## Method to define tear down VPP actions of the test case.
-    #  Overrides tearDown method in VppTestCase class.
-    #  @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 l2fib verbose")
-        self.cli(2, "show error")
-        self.cli(2, "show run")
-        self.cli(2, "show bridge-domain 1 detail")
-
-    ## Class method to create VLAN sub-interface.
-    #  Uses VPP API command to create VLAN sub-interface.
-    #  @param cls The class pointer.
-    #  @param pg_index Integer variable to store the index of the packet
-    #  generator interface to create VLAN sub-interface on.
-    #  @param vlan_id Integer variable to store required VLAN tag value.
-    @classmethod
-    def create_vlan_subif(cls, pg_index, vlan_id):
-        cls.api("create_vlan_subif pg%u vlan %u" % (pg_index, vlan_id))
-
-    ## Class method to create dot1ad sub-interface.
-    #  Use VPP API command to create dot1ad sub-interface.
-    #  @param cls The class pointer.
-    #  @param pg_index Integer variable to store the index of the packet
-    #  generator interface to create dot1ad sub-interface on.
-    #  @param outer_vlan_id Integer variable to store required outer VLAN tag
-    #  value (S-TAG).
-    #  @param inner_vlan_id Integer variable to store required inner VLAN tag
-    #  value (C-TAG).
-    @classmethod
-    def create_dot1ad_subif(cls, pg_index, sub_id, outer_vlan_id,
-                            inner_vlan_id):
-        cls.api("create_subif pg%u sub_id %u outer_vlan_id %u inner_vlan_id"
-                " %u dot1ad" % (pg_index, sub_id, outer_vlan_id, inner_vlan_id))
-
-    ## Base class for interface.
-    #  To define object representation of the interface.
-    class Interface(object):
-        pass
+    def setUp(self):
+        super(TestL2bd, self).setUp()
 
-    ## Sub-class of the interface class.
-    #  To define object representation of the HW interface.
-    class HardInt(Interface):
-        pass
+        # create 3 pg interfaces
+        self.create_pg_interfaces(range(3))
 
-    ## Sub-class of the interface class.
-    #  To define object representation of the SW interface.
-    class SoftInt(Interface):
-        pass
+        # create 2 sub-interfaces for pg1 and pg2
+        self.sub_interfaces = [
+            VppDot1QSubint(self, self.pg1, TestL2bd.dot1q_sub_id),
+            VppDot1QSubint(self, self.pg2, TestL2bd.dot1ad_sub_id)]
 
-    ## Sub-class of the SW interface class.
-    #  To represent the general sub-interface.
-    class Subint(SoftInt):
-        ## The constructor.
-        #  @param sub_id Integer variable to store sub-interface ID.
-        def __init__(self, sub_id):
-            self.sub_id = sub_id
-
-    ## Sub-class of the SW interface class.
-    #  To represent dot1q sub-interface.
-    class Dot1QSubint(Subint):
-        ## The constructor.
-        #  @param sub_id Integer variable to store sub-interface ID.
-        #  @param vlan Integer variable (optional) to store VLAN tag value. Set
-        #  to sub_id value when VLAN tag value not provided.
-        def __init__(self, sub_id, vlan=None):
-            if vlan is None:
-                vlan = sub_id
-            super(TestL2bd.Dot1QSubint, self).__init__(sub_id)
-            self.vlan = vlan
-
-    ## Sub-class of the SW interface class.
-    #  To represent dot1ad sub-interface.
-    class Dot1ADSubint(Subint):
-        ## The constructor.
-        #  @param sub_id Integer variable to store sub-interface ID.
-        #  @param outer_vlan Integer variable to store outer VLAN tag value.
-        #  @param inner_vlan Integer variable to store inner VLAN tag value.
-        def __init__(self, sub_id, outer_vlan, inner_vlan):
-            super(TestL2bd.Dot1ADSubint, self).__init__(sub_id)
-            self.outer_vlan = outer_vlan
-            self.inner_vlan = inner_vlan
-
-    ## Class method to create interfaces and sub-interfaces.
-    #  Current implementation: create three interfaces, then create Dot1Q
-    #  sub-interfaces for the second and the third interface with VLAN tags
-    #  equal to their sub-interface IDs. Set sub-interfaces status to admin-up.
-    #  @param cls The class pointer.
-    #  @param int_nr Integer variable to store the number of interfaces to be
-    #  created.
-    # TODO: Parametrize required numbers of dot1q and dot1ad to be created.
-    @classmethod
-    def create_interfaces_and_subinterfaces(cls, int_nr):
-        ## A class list variable to store interface indexes.
-        cls.interfaces = range(int_nr)
+        # packet flows mapping pg0 -> pg1, pg2, etc.
+        self.flows = dict()
+        self.flows[self.pg0] = [self.pg1, self.pg2]
+        self.flows[self.pg1] = [self.pg0, self.pg2]
+        self.flows[self.pg2] = [self.pg0, self.pg1]
 
-        # Create interfaces
-        cls.create_interfaces(cls.interfaces)
+        # packet sizes
+        self.pg_if_packet_sizes = [64, 512, 1518, 9018]
+        self.sub_if_packet_sizes = [64, 512, 1518 + 4, 9018 + 4]
 
-        # Make vpp_api_test see interfaces created using debug CLI (in function
-        # create_interfaces)
-        cls.api("sw_interface_dump")
+        self.interfaces = list(self.pg_interfaces)
+        self.interfaces.extend(self.sub_interfaces)
 
-        ## A class dictionary variable to store data about interfaces.
-        #  First create an empty dictionary then store interface data there.
-        cls.INT_DETAILS = dict()
+        # Create BD with MAC learning enabled and put interfaces and
+        #  sub-interfaces to this BD
+        for pg_if in self.pg_interfaces:
+            sw_if_index = pg_if.sub_if.sw_if_index if hasattr(pg_if, 'sub_if') \
+                else pg_if.sw_if_index
+            self.vapi.sw_interface_set_l2_bridge(sw_if_index,
+                                                 bd_id=TestL2bd.bd_id)
 
-        # 1st interface is untagged - no sub-interface required
-        cls.INT_DETAILS[0] = cls.HardInt()
+        # setup all interfaces
+        for i in self.interfaces:
+            i.admin_up()
 
-        # 2nd interface is dot1q tagged
-        cls.INT_DETAILS[1] = cls.Dot1QSubint(TestL2bd.dot1q_sub_id,
-                                             TestL2bd.dot1q_tag)
-        cls.create_vlan_subif(1, cls.INT_DETAILS[1].vlan)
+        # mapping between packet-generator index and lists of test hosts
+        self.hosts_by_pg_idx = dict()
 
-        # 3rd interface is dot1ad tagged
-        # FIXME: Wrong packet format/wrong layer on output of interface 2
-        #self.INT_DETAILS[2] = self.Dot1ADSubint(TestL2bd.dot1ad_sub_id, TestL2bd.dot1ad_outer_tag, TestL2bd.dot1ad_inner_tag)
-        #self.create_dot1ad_subif(2, self.INT_DETAILS[2].sub_id, self.INT_DETAILS[2].outer_vlan, self.INT_DETAILS[2].inner_vlan)
+        # create test host entries and inject packets to learn MAC entries in
+        # the bridge-domain
+        self.create_hosts_and_learn(TestL2bd.mac_entries_count)
+        info(self.vapi.cli("show l2fib"))
 
-        # Use dot1q for now.
-        cls.INT_DETAILS[2] = cls.Dot1QSubint(TestL2bd.dot1ad_sub_id,
-                                             TestL2bd.dot1ad_outer_tag)
-        cls.create_vlan_subif(2, cls.INT_DETAILS[2].vlan)
+    def tearDown(self):
+        super(TestL2bd, self).tearDown()
+        if not self.vpp_dead:
+            info(self.vapi.cli("show l2fib verbose"))
+            info(self.vapi.cli("show bridge-domain %s detail" % self.bd_id))
 
-        for i in cls.interfaces:
-            if isinstance(cls.INT_DETAILS[i], cls.Subint):
-                cls.api("sw_interface_set_flags pg%u.%u admin-up"
-                        % (i, cls.INT_DETAILS[i].sub_id))
-        ## @var interfaces
-        #  List variable to store interface indexes.
-        ## @var INT_DETAILS
-        #  Dictionary variable to store data about interfaces.
+    def create_hosts_and_learn(self, count):
+        """
+        Create required number of host MAC addresses and distribute them among
+        interfaces. Create host IPv4 address for every host MAC address. Create
+        L2 MAC packet stream with host MAC addresses per interface to let
+        the bridge domain learn these MAC addresses.
 
-    ## Class method for bridge-domain to learn defined number of MAC addresses.
-    #  Create required number of host MAC addresses and distribute them among
-    #  interfaces. Create host IPv4 address for every host MAC address. Create
-    #  L2 MAC packet stream with host MAC addresses per interface to let
-    #  the bridge domain learn these MAC addresses.
-    #  @param cls The class pointer.
-    #  @param count Integer variable to store the number of MAC addresses to be
-    #  created.
-    @classmethod
-    def create_mac_entries(cls, count):
-        n_int = len(cls.interfaces)
+        :param count: Integer number of hosts to create MAC/IPv4 addresses for.
+        """
+        n_int = len(self.pg_interfaces)
         macs_per_if = count / n_int
-        for i in cls.interfaces:
-            start_nr = macs_per_if*i
-            end_nr = count if i == (n_int - 1) else macs_per_if*(i+1)
-            cls.MY_MACS[i] = []
-            cls.MY_IP4S[i] = []
+        i = -1
+        for pg_if in self.pg_interfaces:
+            i += 1
+            start_nr = macs_per_if * i
+            end_nr = count if i == (n_int - 1) else macs_per_if * (i + 1)
+            self.hosts_by_pg_idx[pg_if.sw_if_index] = []
+            hosts = self.hosts_by_pg_idx[pg_if.sw_if_index]
             packets = []
             for j in range(start_nr, end_nr):
-                cls.MY_MACS[i].append("00:00:00:ff:%02x:%02x" % (i, j))
-                cls.MY_IP4S[i].append("172.17.1%02x.%u" % (i, j))
-                packet = (Ether(dst="ff:ff:ff:ff:ff:ff", src=cls.MY_MACS[i]))
+                host = TestHost(
+                    "00:00:00:ff:%02x:%02x" % (pg_if.sw_if_index, j),
+                    "172.17.1%02x.%u" % (pg_if.sw_if_index, j))
+                packet = (Ether(dst="ff:ff:ff:ff:ff:ff", src=host.mac))
+                hosts.append(host)
+                if hasattr(pg_if, 'sub_if'):
+                    packet = pg_if.sub_if.add_dot1_layer(packet)
                 packets.append(packet)
-            cls.pg_add_stream(i, packets)
-        # Based on the verbosity level set in the system print the log.
-        cls.log("Sending broadcast eth frames for MAC learning", 1)
-        cls.pg_start()
-        # Packet stream capturing is not started as we don't need to read
-        #  the output.
-        ## @var n_int
-        #  Integer variable to store the number of interfaces.
-        ## @var macs_per_if
-        #  Integer variable to store the number of MAC addresses per interface.
-        ## @var start_nr
-        #  Integer variable to store the starting number of the range used to
-        #  generate MAC addresses for the interface.
-        ## @var end_nr
-        #  Integer variable to store the ending number of the range used to
-        #  generate MAC addresses for the interface.
-        ## @var MY_MACS
-        #  Dictionary variable to store list of MAC addresses per interface.
-        ## @var MY_IP4S
-        #  Dictionary variable to store list of IPv4 addresses per interface.
-
-    ## Class method to add dot1q or dot1ad layer to the packet.
-    #  Based on sub-interface data of the defined interface add dot1q or dot1ad
-    #  Ethernet header layer to the packet.
-    #  @param cls The class pointer.
-    #  @param i Integer variable to store the index of the interface.
-    #  @param packet Object variable to store the packet where to add dot1q or
-    #  dot1ad layer.
-    # TODO: Move this class method to utils.py.
-    @classmethod
-    def add_dot1_layers(cls, i, packet):
-        assert(type(packet) is Ether)
-        payload = packet.payload
-        if isinstance(cls.INT_DETAILS[i], cls.Dot1QSubint):
-            packet.remove_payload()
-            packet.add_payload(Dot1Q(vlan=cls.INT_DETAILS[i].vlan) / payload)
-        elif isinstance(cls.INT_DETAILS[i], cls.Dot1ADSubint):
-            packet.remove_payload()
-            packet.add_payload(Dot1Q(vlan=cls.INT_DETAILS[i].outer_vlan,
-                                     type=0x8100) /
-                               Dot1Q(vlan=cls.INT_DETAILS[i].inner_vlan) /
-                               payload)
-            packet.type = 0x88A8
-        ## @var payload
-        #  Object variable to store payload of the packet.
-        ## @var INT_DETAILS
-        #  Dictionary variable to store data about interfaces.
-        ## @var Dot1QSubint
-        #  Class variable representing dot1q sub-interfaces.
-        ## @var Dot1ADSubint
-        #  Class variable representing dot1ad sub-interfaces.
-
-    ## Method to remove dot1q or dot1ad layer from the packet.
-    #  Based on sub-interface data of the defined interface remove dot1q or
-    #  dot1ad layer from the packet.
-    #  @param cls The class pointer.
-    #  @param i Integer variable to store the index of the interface.
-    #  @param packet Object variable to store the packet where to remove dot1q
-    #  or dot1ad layer.
-    def remove_dot1_layers(self, i, packet):
-        self.assertEqual(type(packet), Ether)
-        payload = packet.payload
-        if isinstance(self.INT_DETAILS[i], self.Dot1QSubint):
-            self.assertEqual(type(payload), Dot1Q)
-            self.assertEqual(payload.vlan, self.INT_DETAILS[i].vlan)
-            payload = payload.payload
-        elif isinstance(self.INT_DETAILS[i], self.Dot1ADSubint):  # TODO: change 88A8 type
-            self.assertEqual(type(payload), Dot1Q)
-            self.assertEqual(payload.vlan, self.INT_DETAILS[i].outer_vlan)
-            payload = payload.payload
-            self.assertEqual(type(payload), Dot1Q)
-            self.assertEqual(payload.vlan, self.INT_DETAILS[i].inner_vlan)
-            payload = payload.payload
-        packet.remove_payload()
-        packet.add_payload(payload)
-        ## @var payload
-        #  Object variable to store payload of the packet.
-        ## @var INT_DETAILS
-        #  Dictionary variable to store data about interfaces.
-        ## @var Dot1QSubint
-        #  Class variable representing dot1q sub-interfaces.
-        ## @var Dot1ADSubint
-        #  Class variable representing dot1ad sub-interfaces.
+            pg_if.add_stream(packets)
+        info("Sending broadcast eth frames for MAC learning")
+        self.pg_start()
 
-    ## Method to create packet stream for the packet generator interface.
-    #  Create input packet stream for the given packet generator interface with
-    #  packets of different length targeted for all other created packet
-    #  generator interfaces.
-    #  @param self The object pointer.
-    #  @param pg_id Integer variable to store the index of the interface to
-    #  create the input packet stream.
-    #  @return pkts List variable to store created input stream of packets.
-    def create_stream(self, pg_id):
-        # TODO: use variables to create lists based on interface number
-        pg_targets = [None] * 3
-        pg_targets[0] = [1, 2]
-        pg_targets[1] = [0, 2]
-        pg_targets[2] = [0, 1]
+    def create_stream(self, src_if, packet_sizes):
         pkts = []
         for i in range(0, TestL2bd.pkts_per_burst):
-            target_pg_id = pg_targets[pg_id][i % 2]
-            target_host_id = random.randrange(len(self.MY_MACS[target_pg_id]))
-            source_host_id = random.randrange(len(self.MY_MACS[pg_id]))
-            pkt_info = self.create_packet_info(pg_id, target_pg_id)
+            dst_if = self.flows[src_if][i % 2]
+            dst_host = random.choice(self.hosts_by_pg_idx[dst_if.sw_if_index])
+            src_host = random.choice(self.hosts_by_pg_idx[src_if.sw_if_index])
+            pkt_info = self.create_packet_info(
+                src_if.sw_if_index, dst_if.sw_if_index)
             payload = self.info_to_payload(pkt_info)
-            p = (Ether(dst=self.MY_MACS[target_pg_id][target_host_id],
-                       src=self.MY_MACS[pg_id][source_host_id]) /
-                 IP(src=self.MY_IP4S[pg_id][source_host_id],
-                    dst=self.MY_IP4S[target_pg_id][target_host_id]) /
+            p = (Ether(dst=dst_host.mac, src=src_host.mac) /
+                 IP(src=src_host.ip4, dst=dst_host.ip4) /
                  UDP(sport=1234, dport=1234) /
                  Raw(payload))
             pkt_info.data = p.copy()
-            self.add_dot1_layers(pg_id, p)
-            if not isinstance(self.INT_DETAILS[pg_id], self.Subint):
-                packet_sizes = [64, 512, 1518, 9018]
-            else:
-                packet_sizes = [64, 512, 1518+4, 9018+4]
+            if hasattr(src_if, 'sub_if'):
+                p = src_if.sub_if.add_dot1_layer(p)
             size = packet_sizes[(i / 2) % len(packet_sizes)]
             self.extend_packet(p, size)
             pkts.append(p)
         return pkts
-        ## @var pg_targets
-        #  List variable to store list of indexes of target packet generator
-        #  interfaces for every source packet generator interface.
-        ## @var target_pg_id
-        #  Integer variable to store the index of the random target packet
-        #  generator interfaces.
-        ## @var target_host_id
-        #  Integer variable to store the index of the randomly chosen
-        #  destination host MAC/IPv4 address.
-        ## @var source_host_id
-        #  Integer variable to store the index of the randomly chosen source
-        #  host MAC/IPv4 address.
-        ## @var pkt_info
-        #  Object variable to store the information about the generated packet.
-        ## @var payload
-        #  String variable to store the payload of the packet to be generated.
-        ## @var p
-        #  Object variable to store the generated packet.
-        ## @var packet_sizes
-        #  List variable to store required packet sizes.
-        ## @var size
-        #  List variable to store required packet sizes.
 
-    ## Method to verify packet stream received on the packet generator interface.
-    #  Verify packet-by-packet the output stream captured on a given packet
-    #  generator (pg) interface using following packet payload data - order of
-    #  packet in the stream, index of the source and destination pg interface,
-    #  src and dst host IPv4 addresses and src port and dst port values of UDP
-    #  layer.
-    #  @param self The object pointer.
-    #  @param o Integer variable to store the index of the interface to
-    #  verify the output packet stream.
-    #  @param capture List variable to store the captured output packet stream.
-    def verify_capture(self, o, capture):
-        last_info = {}
-        for i in self.interfaces:
-            last_info[i] = None
+    def verify_capture(self, pg_if, capture):
+        last_info = dict()
+        for i in self.pg_interfaces:
+            last_info[i.sw_if_index] = None
+        dst_sw_if_index = pg_if.sw_if_index
         for packet in capture:
+            payload_info = self.payload_to_info(str(packet[Raw]))
+            src_sw_if_index = payload_info.src
+            src_if = None
+            for ifc in self.pg_interfaces:
+                if ifc != pg_if:
+                    if ifc.sw_if_index == src_sw_if_index:
+                        src_if = ifc
+                        break
+            if hasattr(src_if, 'sub_if'):
+                # Check VLAN tags and Ethernet header
+                packet = src_if.sub_if.remove_dot1_layer(packet)
+            self.assertTrue(Dot1Q not in packet)
             try:
                 ip = packet[IP]
                 udp = packet[UDP]
-                payload_info = self.payload_to_info(str(packet[Raw]))
-                # Check VLAN tags and Ethernet header
-                # TODO: Rework to check VLAN tag(s) and do not remove them
-                self.remove_dot1_layers(payload_info.src, packet)
-                self.assertTrue(Dot1Q not in packet)
-                self.assertEqual(payload_info.dst, o)
-                self.log("Got packet on port %u: src=%u (id=%u)"
-                         % (o, payload_info.src, payload_info.index), 2)
+                packet_index = payload_info.index
+                self.assertEqual(payload_info.dst, dst_sw_if_index)
+                debug("Got packet on port %s: src=%u (id=%u)" %
+                      (pg_if.name, payload_info.src, packet_index))
                 next_info = self.get_next_packet_info_for_interface2(
-                    payload_info.src, payload_info.dst,
+                    payload_info.src, dst_sw_if_index,
                     last_info[payload_info.src])
                 last_info[payload_info.src] = next_info
                 self.assertTrue(next_info is not None)
-                self.assertEqual(payload_info.index, next_info.index)
+                self.assertEqual(packet_index, next_info.index)
+                saved_packet = next_info.data
                 # Check standard fields
-                self.assertEqual(ip.src, next_info.data[IP].src)
-                self.assertEqual(ip.dst, next_info.data[IP].dst)
-                self.assertEqual(udp.sport, next_info.data[UDP].sport)
-                self.assertEqual(udp.dport, next_info.data[UDP].dport)
+                self.assertEqual(ip.src, saved_packet[IP].src)
+                self.assertEqual(ip.dst, saved_packet[IP].dst)
+                self.assertEqual(udp.sport, saved_packet[UDP].sport)
+                self.assertEqual(udp.dport, saved_packet[UDP].dport)
             except:
-                self.log("Unexpected or invalid packet:")
-                packet.show()
+                error("Unexpected or invalid packet:")
+                error(packet.show())
                 raise
-        for i in self.interfaces:
+        for i in self.pg_interfaces:
             remaining_packet = self.get_next_packet_info_for_interface2(
-                i, o, last_info[i])
-            self.assertTrue(remaining_packet is None,
-                            "Port %u: Packet expected from source %u didn't"
-                            " arrive" % (o, i))
-        ## @var last_info
-        #  Dictionary variable to store verified packets per packet generator
-        #  interface.
-        ## @var ip
-        #  Object variable to store the IP layer of the packet.
-        ## @var udp
-        #  Object variable to store the UDP layer of the packet.
-        ## @var payload_info
-        #  Object variable to store required information about the packet.
-        ## @var next_info
-        #  Object variable to store information about next packet.
-        ## @var remaining_packet
-        #  Object variable to store information about remaining packet.
+                i, dst_sw_if_index, last_info[i.sw_if_index])
+            self.assertTrue(
+                remaining_packet is None,
+                "Port %u: Packet expected from source %u didn't arrive" %
+                (dst_sw_if_index, i.sw_if_index))
 
-    ## Method defining VPP L2 bridge domain test case.
-    #  Contains execution steps of the test case.
-    #  @param self The object pointer.
     def test_l2bd(self):
         """ L2BD MAC learning test
 
@@ -447,27 +196,23 @@ class TestL2bd(VppTestCase):
             burst of 257 pkts per interface
         """
 
-        ## Create incoming packet streams for packet-generator interfaces
-        for i in self.interfaces:
-            pkts = self.create_stream(i)
-            self.pg_add_stream(i, pkts)
+        # Create incoming packet streams for packet-generator interfaces
+        for i in self.pg_interfaces:
+            packet_sizes = self.sub_if_packet_sizes if hasattr(i, 'sub_if') \
+                else self.pg_if_packet_sizes
+            pkts = self.create_stream(i, packet_sizes)
+            i.add_stream(pkts)
 
-        ## Enable packet capture and start packet sending
-        self.pg_enable_capture(self.interfaces)
+        # Enable packet capture and start packet sending
+        self.pg_enable_capture(self.pg_interfaces)
         self.pg_start()
 
-        ## Verify outgoing packet streams per packet-generator interface
-        for i in self.interfaces:
-            out = self.pg_get_capture(i)
-            self.log("Verifying capture %u" % i)
-            self.verify_capture(i, out)
-        ## @var pkts
-        #  List variable to store created input stream of packets for the packet
-        #  generator interface.
-        ## @var out
-        #  List variable to store captured output stream of packets for
-        #  the packet generator interface.
+        # Verify outgoing packet streams per packet-generator interface
+        for i in self.pg_interfaces:
+            capture = i.get_capture()
+            info("Verifying capture on interface %s" % i.name)
+            self.verify_capture(i, capture)
 
 
 if __name__ == '__main__':
-    unittest.main(testRunner = VppTestRunner)
+    unittest.main(testRunner=VppTestRunner)
diff --git a/test/test_l2xc.py b/test/test_l2xc.py
index f5fc8743..d448a04d 100644
--- a/test/test_l2xc.py
+++ b/test/test_l2xc.py
@@ -1,210 +1,152 @@
 #!/usr/bin/env python
-## @file test_l2xc.py
-#  Module to provide L2 cross-connect test case.
-#
-#  The module provides a set of tools for L2 cross-connect tests.
-
-import logging
-logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
 
 import unittest
 import random
-from framework import VppTestCase, VppTestRunner
-from scapy.layers.l2 import Ether, Raw
+
+from scapy.packet import Raw
+from scapy.layers.l2 import Ether
 from scapy.layers.inet import IP, UDP
+from logging import *
+
+from framework import VppTestCase, VppTestRunner
+from util import TestHost
 
 
-## Subclass of the VppTestCase class.
-#
-#  This subclass is a class for L2 cross-connect test cases. It provides methods
-#  to create interfaces, configuring L2 cross-connects, creating and verifying
-#  packet streams.
 class TestL2xc(VppTestCase):
     """ L2XC Test Case """
 
     # Test variables
-    interf_nr = 4           # Number of interfaces
     hosts_nr = 10           # Number of hosts
     pkts_per_burst = 257    # Number of packets per burst
 
-    ## Class method to start the test case.
-    #  Overrides setUpClass method in VppTestCase class.
-    #  There is used try..except statement to ensure that the tear down of
-    #  the class will be executed even if any exception is raised.
-    #  @param cls The class pointer.
     @classmethod
     def setUpClass(cls):
         super(TestL2xc, cls).setUpClass()
 
-        try:
-            ## Create interfaces
-            cls.interfaces = range(TestL2xc.interf_nr)
-            cls.create_interfaces(cls.interfaces)
+    def setUp(self):
+        super(TestL2xc, self).setUp()
 
-            ## Create bi-directional cross-connects between pg0 and pg1
-            cls.api("sw_interface_set_l2_xconnect rx pg0 tx pg1 enable")
-            cls.api("sw_interface_set_l2_xconnect rx pg1 tx pg0 enable")
+        # create 4 pg interfaces
+        self.create_pg_interfaces(range(4))
 
-            ## Create bi-directional cross-connects between pg2 and pg3
-            cls.api("sw_interface_set_l2_xconnect rx pg2 tx pg3 enable")
-            cls.api("sw_interface_set_l2_xconnect rx pg3 tx pg2 enable")
+        # packet flows mapping pg0 -> pg1, pg2 -> pg3, etc.
+        self.flows = dict()
+        self.flows[self.pg0] = [self.pg1]
+        self.flows[self.pg1] = [self.pg0]
+        self.flows[self.pg2] = [self.pg3]
+        self.flows[self.pg3] = [self.pg2]
 
-            cls.cli(0, "show l2patch")
+        # packet sizes
+        self.pg_if_packet_sizes = [64, 512, 1518, 9018]
 
-            ## Create host MAC and IPv4 lists
-            cls.create_host_lists(TestL2xc.hosts_nr)
+        self.interfaces = list(self.pg_interfaces)
 
-        except Exception as e:
-            cls.tearDownClass()
-            raise e
+        # Create bi-directional cross-connects between pg0 and pg1
+        self.vapi.sw_interface_set_l2_xconnect(
+            self.pg0.sw_if_index, self.pg1.sw_if_index, enable=1)
+        self.vapi.sw_interface_set_l2_xconnect(
+            self.pg1.sw_if_index, self.pg0.sw_if_index, enable=1)
+
+        # Create bi-directional cross-connects between pg2 and pg3
+        self.vapi.sw_interface_set_l2_xconnect(
+            self.pg2.sw_if_index, self.pg3.sw_if_index, enable=1)
+        self.vapi.sw_interface_set_l2_xconnect(
+            self.pg3.sw_if_index, self.pg2.sw_if_index, enable=1)
+
+        info(self.vapi.cli("show l2patch"))
+
+        # mapping between packet-generator index and lists of test hosts
+        self.hosts_by_pg_idx = dict()
+
+        # Create host MAC and IPv4 lists
+        # self.MY_MACS = dict()
+        # self.MY_IP4S = dict()
+        self.create_host_lists(TestL2xc.hosts_nr)
+
+        # setup all interfaces
+        for i in self.interfaces:
+            i.admin_up()
 
-    ## Method to define tear down VPP actions of the test case.
-    #  Overrides tearDown method in VppTestCase class.
-    #  @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 l2patch")
-        self.cli(2, "show error")
-        self.cli(2, "show run")
-
-    ## Class method to create required number of MAC and IPv4 addresses.
-    #  Create required number of host MAC addresses and distribute them among
-    #  interfaces. Create host IPv4 address for every host MAC address too.
-    #  @param cls The class pointer.
-    #  @param count Integer variable to store the number of MAC addresses to be
-    #  created.
-    @classmethod
-    def create_host_lists(cls, count):
-        for i in cls.interfaces:
-            cls.MY_MACS[i] = []
-            cls.MY_IP4S[i] = []
+        super(TestL2xc, self).tearDown()
+        if not self.vpp_dead:
+            info(self.vapi.cli("show l2patch"))
+
+    def create_host_lists(self, count):
+        """ Method to create required number of MAC and IPv4 addresses.
+        Create required number of host MAC addresses and distribute them among
+        interfaces. Create host IPv4 address for every host MAC address too.
+
+        :param count: Number of hosts to create MAC and IPv4 addresses for.
+        Type: int
+        """
+        for pg_if in self.pg_interfaces:
+            # self.MY_MACS[i.sw_if_index] = []
+            # self.MY_IP4S[i.sw_if_index] = []
+            self.hosts_by_pg_idx[pg_if.sw_if_index] = []
+            hosts = self.hosts_by_pg_idx[pg_if.sw_if_index]
             for j in range(0, count):
-                cls.MY_MACS[i].append("00:00:00:ff:%02x:%02x" % (i, j))
-                cls.MY_IP4S[i].append("172.17.1%02x.%u" % (i, j))
-        ## @var MY_MACS
-        #  Dictionary variable to store list of MAC addresses per interface.
-        ## @var MY_IP4S
-        #  Dictionary variable to store list of IPv4 addresses per interface.
-
-    ## Method to create packet stream for the packet generator interface.
-    #  Create input packet stream for the given packet generator interface with
-    #  packets of different length targeted for all other created packet
-    #  generator interfaces.
-    #  @param self The object pointer.
-    #  @param pg_id Integer variable to store the index of the interface to
-    #  create the input packet stream.
-    #  @return pkts List variable to store created input stream of packets.
-    def create_stream(self, pg_id):
-        # TODO: use variables to create lists based on interface number
-        pg_targets = [None] * 4
-        pg_targets[0] = [1]
-        pg_targets[1] = [0]
-        pg_targets[2] = [3]
-        pg_targets[3] = [2]
+                host = TestHost(
+                    "00:00:00:ff:%02x:%02x" % (pg_if.sw_if_index, j),
+                    "172.17.1%02x.%u" % (pg_if.sw_if_index, j))
+                hosts.append(host)
+
+    def create_stream(self, src_if, packet_sizes):
         pkts = []
         for i in range(0, TestL2xc.pkts_per_burst):
-            target_pg_id = pg_targets[pg_id][0]
-            target_host_id = random.randrange(len(self.MY_MACS[target_pg_id]))
-            source_host_id = random.randrange(len(self.MY_MACS[pg_id]))
-            pkt_info = self.create_packet_info(pg_id, target_pg_id)
+            dst_if = self.flows[src_if][0]
+            dst_host = random.choice(self.hosts_by_pg_idx[dst_if.sw_if_index])
+            src_host = random.choice(self.hosts_by_pg_idx[src_if.sw_if_index])
+            pkt_info = self.create_packet_info(
+                src_if.sw_if_index, dst_if.sw_if_index)
             payload = self.info_to_payload(pkt_info)
-            p = (Ether(dst=self.MY_MACS[target_pg_id][target_host_id],
-                       src=self.MY_MACS[pg_id][source_host_id]) /
-                 IP(src=self.MY_IP4S[pg_id][source_host_id],
-                    dst=self.MY_IP4S[target_pg_id][target_host_id]) /
+            p = (Ether(dst=dst_host.mac, src=src_host.mac) /
+                 IP(src=src_host.ip4, dst=dst_host.ip4) /
                  UDP(sport=1234, dport=1234) /
                  Raw(payload))
             pkt_info.data = p.copy()
-            packet_sizes = [64, 512, 1518, 9018]
             size = packet_sizes[(i / 2) % len(packet_sizes)]
             self.extend_packet(p, size)
             pkts.append(p)
         return pkts
-        ## @var pg_targets
-        #  List variable to store list of indexes of target packet generator
-        #  interfaces for every source packet generator interface.
-        ## @var target_pg_id
-        #  Integer variable to store the index of the random target packet
-        #  generator interfaces.
-        ## @var target_host_id
-        #  Integer variable to store the index of the randomly chosen
-        #  destination host MAC/IPv4 address.
-        ## @var source_host_id
-        #  Integer variable to store the index of the randomly chosen source
-        #  host MAC/IPv4 address.
-        ## @var pkt_info
-        #  Object variable to store the information about the generated packet.
-        ## @var payload
-        #  String variable to store the payload of the packet to be generated.
-        ## @var p
-        #  Object variable to store the generated packet.
-        ## @var packet_sizes
-        #  List variable to store required packet sizes.
-        ## @var size
-        #  List variable to store required packet sizes.
-
-    ## Method to verify packet stream received on the packet generator interface.
-    #  Verify packet-by-packet the output stream captured on a given packet
-    #  generator (pg) interface using following packet payload data - order of
-    #  packet in the stream, index of the source and destination pg interface,
-    #  src and dst host IPv4 addresses and src port and dst port values of UDP
-    #  layer.
-    #  @param self The object pointer.
-    #  @param o Integer variable to store the index of the interface to
-    #  verify the output packet stream.
-    #  @param capture List variable to store the captured output packet stream.
-    def verify_capture(self, o, capture):
-        last_info = {}
+
+    def verify_capture(self, pg_if, capture):
+        last_info = dict()
         for i in self.interfaces:
-            last_info[i] = None
+            last_info[i.sw_if_index] = None
+        dst_sw_if_index = pg_if.sw_if_index
         for packet in capture:
             try:
                 ip = packet[IP]
                 udp = packet[UDP]
                 payload_info = self.payload_to_info(str(packet[Raw]))
-                self.assertEqual(payload_info.dst, o)
-                self.log("Got packet on port %u: src=%u (id=%u)"
-                         % (o, payload_info.src, payload_info.index), 2)
+                packet_index = payload_info.index
+                self.assertEqual(payload_info.dst, dst_sw_if_index)
+                debug("Got packet on port %s: src=%u (id=%u)" %
+                      (pg_if.name, payload_info.src, packet_index))
                 next_info = self.get_next_packet_info_for_interface2(
-                    payload_info.src, payload_info.dst,
+                    payload_info.src, dst_sw_if_index,
                     last_info[payload_info.src])
                 last_info[payload_info.src] = next_info
                 self.assertTrue(next_info is not None)
-                self.assertEqual(payload_info.index, next_info.index)
+                self.assertEqual(packet_index, next_info.index)
+                saved_packet = next_info.data
                 # Check standard fields
-                self.assertEqual(ip.src, next_info.data[IP].src)
-                self.assertEqual(ip.dst, next_info.data[IP].dst)
-                self.assertEqual(udp.sport, next_info.data[UDP].sport)
-                self.assertEqual(udp.dport, next_info.data[UDP].dport)
+                self.assertEqual(ip.src, saved_packet[IP].src)
+                self.assertEqual(ip.dst, saved_packet[IP].dst)
+                self.assertEqual(udp.sport, saved_packet[UDP].sport)
+                self.assertEqual(udp.dport, saved_packet[UDP].dport)
             except:
-                self.log("Unexpected or invalid packet:")
+                error("Unexpected or invalid packet:")
                 packet.show()
                 raise
         for i in self.interfaces:
             remaining_packet = self.get_next_packet_info_for_interface2(
-                i, o, last_info[i])
+                i, dst_sw_if_index, last_info[i.sw_if_index])
             self.assertTrue(remaining_packet is None,
                             "Port %u: Packet expected from source %u didn't"
-                            " arrive" % (o, i))
-        ## @var last_info
-        #  Dictionary variable to store verified packets per packet generator
-        #  interface.
-        ## @var ip
-        #  Object variable to store the IP layer of the packet.
-        ## @var udp
-        #  Object variable to store the UDP layer of the packet.
-        ## @var payload_info
-        #  Object variable to store required information about the packet.
-        ## @var next_info
-        #  Object variable to store information about next packet.
-        ## @var remaining_packet
-        #  Object variable to store information about remaining packet.
-
-    ## Method defining L2 cross-connect test case.
-    #  Contains steps of the test case.
-    #  @param self The object pointer.
+                            " arrive" % (dst_sw_if_index, i.sw_if_index))
+
     def test_l2xc(self):
         """ L2XC test
 
@@ -217,27 +159,21 @@ class TestL2xc(VppTestCase):
             burst of packets per interface
         """
 
-        ## Create incoming packet streams for packet-generator interfaces
+        # Create incoming packet streams for packet-generator interfaces
         for i in self.interfaces:
-            pkts = self.create_stream(i)
-            self.pg_add_stream(i, pkts)
+            pkts = self.create_stream(i, self.pg_if_packet_sizes)
+            i.add_stream(pkts)
 
-        ## Enable packet capturing and start packet sending
-        self.pg_enable_capture(self.interfaces)
+        # Enable packet capturing and start packet sending
+        self.pg_enable_capture(self.pg_interfaces)
         self.pg_start()
 
-        ## Verify outgoing packet streams per packet-generator interface
-        for i in self.interfaces:
-            out = self.pg_get_capture(i)
-            self.log("Verifying capture %u" % i)
-            self.verify_capture(i, out)
-        ## @var pkts
-        #  List variable to store created input stream of packets for the packet
-        #  generator interface.
-        ## @var out
-        #  List variable to store captured output stream of packets for
-        #  the packet generator interface.
+        # Verify outgoing packet streams per packet-generator interface
+        for i in self.pg_interfaces:
+            capture = i.get_capture()
+            info("Verifying capture on interface %s" % i.name)
+            self.verify_capture(i, capture)
 
 
 if __name__ == '__main__':
-    unittest.main(testRunner = VppTestRunner)
+    unittest.main(testRunner=VppTestRunner)
diff --git a/test/test_lb.py b/test/test_lb.py
index eb308195..76fdd693 100644
--- a/test/test_lb.py
+++ b/test/test_lb.py
@@ -1,27 +1,30 @@
-import unittest
-import time
 import socket
-from framework import VppTestCase, VppTestRunner
-from util import Util
+import unittest
+from logging import *
 
-from scapy.packet import Raw
-from scapy.layers.l2 import Ether, GRE
 from scapy.layers.inet import IP, UDP
 from scapy.layers.inet6 import IPv6
+from scapy.layers.l2 import Ether, GRE
+from scapy.packet import Raw
+
+from framework import VppTestCase
+
+""" TestLB is a subclass of  VPPTestCase classes.
+
+ TestLB class defines Load Balancer test cases for:
+  - IP4 to GRE4 encap
+  - IP4 to GRE6 encap
+  - IP6 to GRE4 encap
+  - IP6 to GRE6 encap
+
+ As stated in comments below, GRE has issues with IPv6.
+ All test cases involving IPv6 are executed, but
+ received packets are not parsed and checked.
+
+"""
 
-## TestLB is a subclass of Util and VPPTestCase classes.
-#
-#  TestLB class defines Load Balancer test cases for:
-#   - IP4 to GRE4 encap
-#   - IP4 to GRE6 encap
-#   - IP6 to GRE4 encap
-#   - IP6 to GRE6 encap
-#
-#  As stated in comments below, GRE has issues with IPv6.
-#  All test cases involving IPv6 are executed, but
-#  received packets are not parsed and checked.
-#
-class TestLB(Util, VppTestCase):
+
+class TestLB(VppTestCase):
     """ Load Balancer Test Case """
 
     @classmethod
@@ -32,61 +35,73 @@ class TestLB(Util, VppTestCase):
         cls.packets = range(100)
 
         try:
-            cls.create_interfaces([0,1])
-            cls.api("sw_interface_dump")
-            cls.config_ip4([0,1])
-            cls.config_ip6([0,1])
-            cls.resolve_arp([0,1])
-            cls.resolve_icmpv6_nd([0,1])
-            cls.cli(0, "ip route add 10.0.0.0/24 via %s pg1" % (cls.MY_IP4S[1]))
-            cls.cli(0, "ip route add 2002::/16 via %s pg1" % (cls.MY_IP6S[1]))
-            cls.cli(0, "lb conf buckets-log2 20 ip4-src-address 39.40.41.42 ip6-src-address fd00:f00d::1")
-
-        except Exception as e:
+            cls.create_pg_interfaces(range(2))
+            cls.interfaces = list(cls.pg_interfaces)
+
+            for i in cls.interfaces:
+                i.admin_up()
+                i.config_ip4()
+                i.config_ip6()
+                i.disable_ipv6_ra()
+                i.resolve_arp()
+                i.resolve_ndp()
+            dst4 = socket.inet_pton(socket.AF_INET, "10.0.0.0")
+            dst6 = socket.inet_pton(socket.AF_INET6, "2002::")
+            cls.vapi.ip_add_del_route(dst4, 24, cls.pg1.remote_ip4n)
+            cls.vapi.ip_add_del_route(dst6, 16, cls.pg1.remote_ip6n, is_ipv6=1)
+            cls.vapi.cli("lb conf ip4-src-address 39.40.41.42")
+            cls.vapi.cli("lb conf ip6-src-address 2004::1")
+        except Exception:
             super(TestLB, cls).tearDownClass()
             raise
 
     def tearDown(self):
-        self.cli(2, "show int")
-        self.cli(2, "show trace")
-        self.cli(2, "show lb vip verbose")
+        super(TestLB, self).tearDown()
+        if not self.vpp_dead:
+            info(self.vapi.cli("show lb vip verbose"))
 
     def getIPv4Flow(self, id):
         return (IP(dst="90.0.%u.%u" % (id / 255, id % 255),
-              src="40.0.%u.%u" % (id / 255, id % 255)) /
+                   src="40.0.%u.%u" % (id / 255, id % 255)) /
                 UDP(sport=10000 + id, dport=20000 + id))
 
     def getIPv6Flow(self, id):
         return (IPv6(dst="2001::%u" % (id), src="fd00:f00d:ffff::%u" % (id)) /
-            UDP(sport=10000 + id, dport=20000 + id))
+                UDP(sport=10000 + id, dport=20000 + id))
 
-    def generatePackets(self, isv4):
+    def generatePackets(self, src_if, isv4):
         pkts = []
         for pktid in self.packets:
-            info = self.create_packet_info(0, pktid)
+            info = self.create_packet_info(src_if.sw_if_index, pktid)
             payload = self.info_to_payload(info)
             ip = self.getIPv4Flow(pktid) if isv4 else self.getIPv6Flow(pktid)
-            packet=(Ether(dst=self.VPP_MACS[0], src=self.MY_MACS[0]) /
-                    ip / Raw(payload))
+            packet = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
+                      ip /
+                      Raw(payload))
             self.extend_packet(packet, 128)
             info.data = packet.copy()
             pkts.append(packet)
         return pkts
 
     def checkInner(self, gre, isv4):
+        IPver = IP if isv4 else IPv6
         self.assertEqual(gre.proto, 0x0800 if isv4 else 0x86DD)
         self.assertEqual(gre.flags, 0)
         self.assertEqual(gre.version, 0)
-        inner = gre[IP] if isv4 else gre[IPv6]
-        payload_info = self.payload_to_info(str(gre[Raw]))
+        inner = IPver(str(gre.payload))
+        payload_info = self.payload_to_info(str(inner[Raw]))
         packet_index = payload_info.index
-        self.info = self.get_next_packet_info_for_interface2(0, payload_info.dst, self.info)
-        self.assertEqual(str(inner), str(self.info.data[IP]))
+        self.info = self.get_next_packet_info_for_interface2(self.pg0.sw_if_index,
+                                                             payload_info.dst,
+                                                             self.info)
+        self.assertEqual(str(inner), str(self.info.data[IPver]))
 
     def checkCapture(self, gre4, isv4):
-        out = self.pg_get_capture(0)
-        self.assertEqual(len(out), 0)
-        out = self.pg_get_capture(1)
+        out = self.pg0.get_capture()
+        # This check is edited because RA appears in output, maybe disable RA?
+        # self.assertEqual(len(out), 0)
+        self.assertLess(len(out), 20)
+        out = self.pg1.get_capture()
         self.assertEqual(len(out), len(self.packets))
 
         load = [0] * len(self.ass)
@@ -97,8 +112,6 @@ class TestLB(Util, VppTestCase):
                 gre = None
                 if gre4:
                     ip = p[IP]
-                    gre = p[GRE]
-                    inner = gre[IP] if isv4 else gre[IPv6]
                     asid = int(ip.dst.split(".")[3])
                     self.assertEqual(ip.version, 4)
                     self.assertEqual(ip.flags, 0)
@@ -106,105 +119,108 @@ class TestLB(Util, VppTestCase):
                     self.assertEqual(ip.dst, "10.0.0.%u" % asid)
                     self.assertEqual(ip.proto, 47)
                     self.assertEqual(len(ip.options), 0)
-                    self.assertTrue(ip.ttl >= 64)
+                    self.assertGreaterEqual(ip.ttl, 64)
+                    gre = p[GRE]
                 else:
                     ip = p[IPv6]
-                    gre = p[GRE]
-                    inner = gre[IP] if isv4 else gre[IPv6]
                     asid = ip.dst.split(":")
                     asid = asid[len(asid) - 1]
-                    asid = 0 if asid=="" else int(asid)
+                    asid = 0 if asid == "" else int(asid)
                     self.assertEqual(ip.version, 6)
-                    # Todo: Given scapy... I will do that when it works.
+                    self.assertEqual(ip.tc, 0)
+                    self.assertEqual(ip.fl, 0)
+                    self.assertEqual(ip.src, "2004::1")
+                    self.assertEqual(
+                        socket.inet_pton(socket.AF_INET6, ip.dst),
+                        socket.inet_pton(socket.AF_INET6, "2002::%u" % asid)
+                    )
+                    self.assertEqual(ip.nh, 47)
+                    self.assertGreaterEqual(ip.hlim, 64)
+                    # self.assertEqual(len(ip.options), 0)
+                    gre = GRE(str(p[IPv6].payload))
                 self.checkInner(gre, isv4)
                 load[asid] += 1
             except:
-                self.log("Unexpected or invalid packet:")
+                error("Unexpected or invalid packet:")
                 p.show()
                 raise
 
         # This is just to roughly check that the balancing algorithm
         # is not completly biased.
         for asid in self.ass:
-            if load[asid] < len(self.packets)/(len(self.ass)*2):
-                self.log("ASS is not balanced: load[%d] = %d" % (asid, load[asid]))
+            if load[asid] < len(self.packets) / (len(self.ass) * 2):
+                self.log(
+                    "ASS is not balanced: load[%d] = %d" % (asid, load[asid]))
                 raise Exception("Load Balancer algorithm is biased")
 
-
     def test_lb_ip4_gre4(self):
         """ Load Balancer IP4 GRE4 """
+        try:
+            self.vapi.cli("lb vip 90.0.0.0/8 encap gre4")
+            for asid in self.ass:
+                self.vapi.cli("lb as 90.0.0.0/8 10.0.0.%u" % (asid))
 
-        return
-        self.cli(0, "lb vip 90.0.0.0/8 encap gre4")
-        for asid in self.ass:
-            self.cli(0, "lb as 90.0.0.0/8 10.0.0.%u" % (asid))
-
-        self.pg_add_stream(0, self.generatePackets(1))
-        self.pg_enable_capture([0,1])
-        self.pg_start()
-        self.checkCapture(1, 1)
-
-        for asid in self.ass:
-            self.cli(0, "lb as 90.0.0.0/8 10.0.0.%u del" % (asid))
-        self.cli(0, "lb vip 90.0.0.0/8 encap gre4 del")
+            self.pg0.add_stream(self.generatePackets(self.pg0, isv4=True))
+            self.pg_enable_capture(self.pg_interfaces)
+            self.pg_start()
+            self.checkCapture(gre4=True, isv4=True)
 
+        finally:
+            for asid in self.ass:
+                self.vapi.cli("lb as 90.0.0.0/8 10.0.0.%u del" % (asid))
+            self.vapi.cli("lb vip 90.0.0.0/8 encap gre4 del")
 
     def test_lb_ip6_gre4(self):
         """ Load Balancer IP6 GRE4 """
 
-        self.cli(0, "lb vip 2001::/16 encap gre4")
-        for asid in self.ass:
-            self.cli(0, "lb as 2001::/16 10.0.0.%u" % (asid))
-
-        self.pg_add_stream(0, self.generatePackets(0))
-        self.pg_enable_capture([0,1])
-        self.pg_start()
-
-        # Scapy fails parsing IPv6 over GRE.
-        # This check is therefore disabled for now.
-        #self.checkCapture(1, 0)
+        try:
+            self.vapi.cli("lb vip 2001::/16 encap gre4")
+            for asid in self.ass:
+                self.vapi.cli("lb as 2001::/16 10.0.0.%u" % (asid))
 
-        for asid in self.ass:
-            self.cli(0, "lb as 2001::/16 10.0.0.%u del" % (asid))
-        self.cli(0, "lb vip 2001::/16 encap gre4 del")
+            self.pg0.add_stream(self.generatePackets(self.pg0, isv4=False))
+            self.pg_enable_capture(self.pg_interfaces)
+            self.pg_start()
 
+            self.checkCapture(gre4=True, isv4=False)
+        finally:
+            for asid in self.ass:
+                self.vapi.cli("lb as 2001::/16 10.0.0.%u del" % (asid))
+            self.vapi.cli("lb vip 2001::/16 encap gre4 del")
 
     def test_lb_ip4_gre6(self):
         """ Load Balancer IP4 GRE6 """
-
-        self.cli(0, "lb vip 90.0.0.0/8 encap gre6")
-        for asid in self.ass:
-            self.cli(0, "lb as 90.0.0.0/8 2002::%u" % (asid))
-
-        self.pg_add_stream(0, self.generatePackets(1))
-        self.pg_enable_capture([0,1])
-        self.pg_start()
-
-        # Scapy fails parsing GRE over IPv6.
-        # This check is therefore disabled for now.
-        # One can easily patch layers/inet6.py to fix the issue.
-        #self.checkCapture(0, 1)
-
-        for asid in self.ass:
-            self.cli(0, "lb as 90.0.0.0/8 2002::%u" % (asid))
-        self.cli(0, "lb vip 90.0.0.0/8 encap gre6 del")
+        try:
+            self.vapi.cli("lb vip 90.0.0.0/8 encap gre6")
+            for asid in self.ass:
+                self.vapi.cli("lb as 90.0.0.0/8 2002::%u" % (asid))
+
+            self.pg0.add_stream(self.generatePackets(self.pg0, isv4=True))
+            self.pg_enable_capture(self.pg_interfaces)
+            self.pg_start()
+
+            # Scapy fails parsing GRE over IPv6.
+            # This check is therefore disabled for now.
+            # One can easily patch layers/inet6.py to fix the issue.
+            self.checkCapture(gre4=False, isv4=True)
+        finally:
+            for asid in self.ass:
+                self.vapi.cli("lb as 90.0.0.0/8 2002::%u" % (asid))
+            self.vapi.cli("lb vip 90.0.0.0/8 encap gre6 del")
 
     def test_lb_ip6_gre6(self):
         """ Load Balancer IP6 GRE6 """
-
-        self.cli(0, "lb vip 2001::/16 encap gre6")
-        for asid in self.ass:
-            self.cli(0, "lb as 2001::/16 2002::%u" % (asid))
-
-        self.pg_add_stream(0, self.generatePackets(0))
-        self.pg_enable_capture([0,1])
-        self.pg_start()
-
-        # Scapy fails parsing IPv6 over GRE and IPv6 over GRE.
-        # This check is therefore disabled for now.
-        #self.checkCapture(0, 0)
-
-        for asid in self.ass:
-            self.cli(0, "lb as 2001::/16 2002::%u del" % (asid))
-        self.cli(0, "lb vip 2001::/16 encap gre6 del")
-
+        try:
+            self.vapi.cli("lb vip 2001::/16 encap gre6")
+            for asid in self.ass:
+                self.vapi.cli("lb as 2001::/16 2002::%u" % (asid))
+
+            self.pg0.add_stream(self.generatePackets(self.pg0, isv4=False))
+            self.pg_enable_capture(self.pg_interfaces)
+            self.pg_start()
+
+            self.checkCapture(gre4=False, isv4=False)
+        finally:
+            for asid in self.ass:
+                self.vapi.cli("lb as 2001::/16 2002::%u del" % (asid))
+            self.vapi.cli("lb vip 2001::/16 encap gre6 del")
diff --git a/test/test_vxlan.py b/test/test_vxlan.py
index 1db34927..cb7e7acf 100644
--- a/test/test_vxlan.py
+++ b/test/test_vxlan.py
@@ -1,8 +1,8 @@
 #!/usr/bin/env python
 
 import unittest
+from logging import *
 from framework import VppTestCase, VppTestRunner
-from util import Util
 from template_bd import BridgeDomain
 
 from scapy.layers.l2 import Ether
@@ -10,61 +10,49 @@ from scapy.layers.inet import IP, UDP
 from scapy_handlers.vxlan import VXLAN
 
 
-## TestVxlan is a subclass of BridgeDomain, Util, VppTestCase classes.
-#
-#  TestVxlan class defines VXLAN test cases for VXLAN encapsulation,
-#  decapsulation and VXLAN tunnel termination in L2 bridge-domain.
-class TestVxlan(BridgeDomain, Util, VppTestCase):
+class TestVxlan(BridgeDomain, VppTestCase):
     """ VXLAN Test Case """
 
-    ## Method to initialize all parent classes.
-    #
-    #  Initialize BridgeDomain objects, set documentation string for inherited
-    #  tests and initialize VppTestCase object which must be called after
-    #  doc strings are set.
     def __init__(self, *args):
         BridgeDomain.__init__(self)
-        self.test_decap.__func__.__doc__ = ' VXLAN BD decapsulation '
-        self.test_encap.__func__.__doc__ = ' VXLAN BD encapsulation '
         VppTestCase.__init__(self, *args)
 
-    ## Method for VXLAN encapsulate function.
-    #
-    #  Encapsulate the original payload frame by adding VXLAN header with its
-    #  UDP, IP and Ethernet fields.
     def encapsulate(self, pkt):
-        return (Ether(src=self.MY_MACS[0], dst=self.VPP_MACS[0]) /
-                IP(src=self.MY_IP4S[0], dst=self.VPP_IP4S[0]) /
-                UDP(sport=4789, dport=4789, chksum=0) /
-                VXLAN(vni=1) /
+        """
+        Encapsulate the original payload frame by adding VXLAN header with its
+        UDP, IP and Ethernet fields
+        """
+        return (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
+                IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) /
+                UDP(sport=self.dport, dport=self.dport, chksum=0) /
+                VXLAN(vni=self.vni) /
                 pkt)
 
-    ## Method for VXLAN decapsulate function.
-    #
-    #  Decapsulate the original payload frame by removing VXLAN header with
-    #  its UDP, IP and Ethernet fields.
     def decapsulate(self, pkt):
+        """
+        Decapsulate the original payload frame by removing VXLAN header
+        """
         return pkt[VXLAN].payload
 
-    ## Method for checking VXLAN encapsulation.
+    # Method for checking VXLAN encapsulation.
     #
     def check_encapsulation(self, pkt):
         # TODO: add error messages
-        ## Verify source MAC is VPP_MAC and destination MAC is MY_MAC resolved
+        # Verify source MAC is VPP_MAC and destination MAC is MY_MAC resolved
         #  by VPP using ARP.
-        self.assertEqual(pkt[Ether].src, self.VPP_MACS[0])
-        self.assertEqual(pkt[Ether].dst, self.MY_MACS[0])
-        ## Verify VXLAN tunnel source IP is VPP_IP and destination IP is MY_IP.
-        self.assertEqual(pkt[IP].src, self.VPP_IP4S[0])
-        self.assertEqual(pkt[IP].dst, self.MY_IP4S[0])
-        ## Verify UDP destination port is VXLAN 4789, source UDP port could be
+        self.assertEqual(pkt[Ether].src, self.pg0.local_mac)
+        self.assertEqual(pkt[Ether].dst, self.pg0.remote_mac)
+        # Verify VXLAN tunnel source IP is VPP_IP and destination IP is MY_IP.
+        self.assertEqual(pkt[IP].src, self.pg0.local_ip4)
+        self.assertEqual(pkt[IP].dst, self.pg0.remote_ip4)
+        # Verify UDP destination port is VXLAN 4789, source UDP port could be
         #  arbitrary.
-        self.assertEqual(pkt[UDP].dport, 4789)
+        self.assertEqual(pkt[UDP].dport, type(self).dport)
         # TODO: checksum check
-        ## Verify VNI, based on configuration it must be 1.
-        self.assertEqual(pkt[VXLAN].vni, 1)
+        # Verify VNI, based on configuration it must be 1.
+        self.assertEqual(pkt[VXLAN].vni, type(self).vni)
 
-    ## Class method to start the VXLAN test case.
+    # Class method to start the VXLAN test case.
     #  Overrides setUpClass method in VppTestCase class.
     #  Python try..except statement is used to ensure that the tear down of
     #  the class will be executed even if exception is raised.
@@ -72,31 +60,41 @@ class TestVxlan(BridgeDomain, Util, VppTestCase):
     @classmethod
     def setUpClass(cls):
         super(TestVxlan, cls).setUpClass()
+
         try:
-            ## Create 2 pg interfaces.
-            cls.create_interfaces(range(2))
-            ## Configure IPv4 addresses on VPP pg0.
-            cls.config_ip4([0])
-            ## Resolve MAC address for VPP's IP address on pg0.
-            cls.resolve_arp([0])
-
-            ## Create VXLAN VTEP on VPP pg0, and put vxlan_tunnel0 and pg1
+            cls.dport = 4789
+            cls.vni = 1
+
+            # Create 2 pg interfaces.
+            cls.create_pg_interfaces(range(2))
+            cls.pg0.admin_up()
+            cls.pg1.admin_up()
+
+            # Configure IPv4 addresses on VPP pg0.
+            cls.pg0.config_ip4()
+
+            # Resolve MAC address for VPP's IP address on pg0.
+            cls.pg0.resolve_arp()
+
+            # Create VXLAN VTEP on VPP pg0, and put vxlan_tunnel0 and pg1
             #  into BD.
-            cls.api("vxlan_add_del_tunnel src %s dst %s vni 1" %
-                    (cls.VPP_IP4S[0], cls.MY_IP4S[0]))
-            cls.api("sw_interface_set_l2_bridge vxlan_tunnel0 bd_id 1")
-            cls.api("sw_interface_set_l2_bridge pg1 bd_id 1")
-        except:
-            ## In case setUpClass fails run tear down.
-            cls.tearDownClass()
+            r = cls.vapi.vxlan_add_del_tunnel(
+                src_addr=cls.pg0.local_ip4n,
+                dst_addr=cls.pg0.remote_ip4n,
+                vni=cls.vni)
+            cls.vapi.sw_interface_set_l2_bridge(r.sw_if_index, bd_id=1)
+            cls.vapi.sw_interface_set_l2_bridge(cls.pg1.sw_if_index, bd_id=1)
+        except Exception:
+            super(TestVxlan, cls).tearDownClass()
             raise
 
-    ## Method to define VPP actions before tear down of the test case.
+    # Method to define VPP actions before tear down of the test case.
     #  Overrides tearDown method in VppTestCase class.
     #  @param self The object pointer.
     def tearDown(self):
         super(TestVxlan, self).tearDown()
-        self.cli(2, "show bridge-domain 1 detail")
+        if not self.vpp_dead:
+            info(self.vapi.cli("show bridge-domain 1 detail"))
 
 if __name__ == '__main__':
     unittest.main(testRunner=VppTestRunner)
diff --git a/test/util.py b/test/util.py
index c72a3965..8d7c9202 100644
--- a/test/util.py
+++ b/test/util.py
@@ -1,139 +1,25 @@
-## @package util
-#  Module with common functions that should be used by the test cases.
-#
-#  The module provides a set of tools for setup the test environment
+from logging import *
 
-from scapy.layers.l2 import Ether, ARP
-from scapy.layers.inet6 import IPv6, ICMPv6ND_NS, ICMPv6NDOptSrcLLAddr
 
+class TestHost(object):
+    """ Generic test host "connected" to VPP. """
 
-## Util class
-#
-#  Test cases that want to use methods defined in Util class should
-#  inherit this class.
-#
-#  class Example(Util, VppTestCase):
-#      pass
-class Util(object):
+    @property
+    def mac(self):
+        """ MAC address """
+        return self._mac
 
-    ## Class method to send ARP Request for each VPP IPv4 address in
-    #  order to determine VPP interface MAC address to IPv4 bindings.
-    #
-    #  Resolved MAC address is saved to the VPP_MACS dictionary with interface
-    #  index as a key. ARP Request is sent from MAC in MY_MACS dictionary with
-    #  interface index as a key.
-    #  @param cls The class pointer.
-    #  @param args List variable to store indices of VPP interfaces.
-    @classmethod
-    def resolve_arp(cls, args):
-        for i in args:
-            ip = cls.VPP_IP4S[i]
-            cls.log("Sending ARP request for %s on port %u" % (ip, i))
-            arp_req = (Ether(dst="ff:ff:ff:ff:ff:ff", src=cls.MY_MACS[i]) /
-                       ARP(op=ARP.who_has, pdst=ip,
-                           psrc=cls.MY_IP4S[i], hwsrc=cls.MY_MACS[i]))
-            cls.pg_add_stream(i, arp_req)
-            cls.pg_enable_capture([i])
+    @property
+    def ip4(self):
+        """ IPv4 address """
+        return self._ip4
 
-            cls.cli(2, "trace add pg-input 1")
-            cls.pg_start()
-            arp_reply = cls.pg_get_capture(i)[0]
-            if arp_reply[ARP].op == ARP.is_at:
-                cls.log("VPP pg%u MAC address is %s " % (i, arp_reply[ARP].hwsrc))
-                cls.VPP_MACS[i] = arp_reply[ARP].hwsrc
-            else:
-                cls.log("No ARP received on port %u" % i)
-            cls.cli(2, "show trace")
-            ## @var ip
-            #  <TODO add description>
-            ## @var arp_req
-            #  <TODO add description>
-            ## @var arp_reply
-            #  <TODO add description>
-            ## @var VPP_MACS
-            #  <TODO add description>
+    @property
+    def ip6(self):
+        """ IPv6 address """
+        return self._ip6
 
-    ## Class method to send ND request for each VPP IPv6 address in
-    #  order to determine VPP MAC address to IPv6 bindings.
-    #
-    #  Resolved MAC address is saved to the VPP_MACS dictionary with interface
-    #  index as a key. ND Request is sent from MAC in MY_MACS dictionary with
-    #  interface index as a key.
-    #  @param cls The class pointer.
-    #  @param args List variable to store indices of VPP interfaces.
-    @classmethod
-    def resolve_icmpv6_nd(cls, args):
-        for i in args:
-            ip = cls.VPP_IP6S[i]
-            cls.log("Sending ICMPv6ND_NS request for %s on port %u" % (ip, i))
-            nd_req = (Ether(dst="ff:ff:ff:ff:ff:ff", src=cls.MY_MACS[i]) /
-                      IPv6(src=cls.MY_IP6S[i], dst=ip) /
-                      ICMPv6ND_NS(tgt=ip) /
-                      ICMPv6NDOptSrcLLAddr(lladdr=cls.MY_MACS[i]))
-            cls.pg_add_stream(i, nd_req)
-            cls.pg_enable_capture([i])
-
-            cls.cli(2, "trace add pg-input 1")
-            cls.pg_start()
-            nd_reply = cls.pg_get_capture(i)[0]
-            icmpv6_na = nd_reply['ICMPv6 Neighbor Discovery - Neighbor Advertisement']
-            dst_ll_addr = icmpv6_na['ICMPv6 Neighbor Discovery Option - Destination Link-Layer Address']
-            cls.VPP_MACS[i] = dst_ll_addr.lladdr
-            ## @var ip
-            #  <TODO add description>
-            ## @var nd_req
-            #  <TODO add description>
-            ## @var nd_reply
-            #  <TODO add description>
-            ## @var icmpv6_na
-            #  <TODO add description>
-            ## @var dst_ll_addr
-            #  <TODO add description>
-            ## @var VPP_MACS
-            #  <TODO add description>
-
-    ## Class method to configure IPv4 addresses on VPP interfaces.
-    #
-    #  Set dictionary variables MY_IP4S and VPP_IP4S to IPv4 addresses
-    #  calculated using interface VPP interface index as a parameter.
-    #  /24 IPv4 prefix is used, with VPP interface address host part set
-    #  to .1 and MY address set to .2.
-    #  Used IPv4 prefix scheme: 172.16.{VPP-interface-index}.0/24.
-    #  @param cls The class pointer.
-    #  @param args List variable to store indices of VPP interfaces.
-    @classmethod
-    def config_ip4(cls, args):
-        for i in args:
-            cls.MY_IP4S[i] = "172.16.%u.2" % i
-            cls.VPP_IP4S[i] = "172.16.%u.1" % i
-            cls.api("sw_interface_add_del_address pg%u %s/24" % (i, cls.VPP_IP4S[i]))
-            cls.log("My IPv4 address is %s" % (cls.MY_IP4S[i]))
-            ## @var MY_IP4S
-            #  Dictionary variable to store host IPv4 addresses connected to packet
-            #  generator interfaces.
-            ## @var VPP_IP4S
-            #  Dictionary variable to store VPP IPv4 addresses of the packet
-            #  generator interfaces.
-
-    ## Class method to configure IPv6 addresses on VPP interfaces.
-    #
-    #  Set dictionary variables MY_IP6S and VPP_IP6S to IPv6 addresses
-    #  calculated using interface VPP interface index as a parameter.
-    #  /64 IPv6 prefix is used, with VPP interface address host part set
-    #  to ::1 and MY address set to ::2.
-    #  Used IPv6 prefix scheme: fd10:{VPP-interface-index}::0/64.
-    #  @param cls The class pointer.
-    #  @param args List variable to store indices of VPP interfaces.
-    @classmethod
-    def config_ip6(cls, args):
-        for i in args:
-            cls.MY_IP6S[i] = "fd10:%u::2" % i
-            cls.VPP_IP6S[i] = "fd10:%u::1" % i
-            cls.api("sw_interface_add_del_address pg%u %s/64" % (i, cls.VPP_IP6S[i]))
-            cls.log("My IPv6 address is %s" % (cls.MY_IP6S[i]))
-            ## @var MY_IP6S
-            #  Dictionary variable to store host IPv6 addresses connected to packet
-            #  generator interfaces.
-            ## @var VPP_IP6S
-            #  Dictionary variable to store VPP IPv6 addresses of the packet
-            #  generator interfaces.
+    def __init__(self, mac=None, ip4=None, ip6=None):
+        self._mac = mac
+        self._ip4 = ip4
+        self._ip6 = ip6
diff --git a/test/vpp_interface.py b/test/vpp_interface.py
new file mode 100644
index 00000000..c596ab5a
--- /dev/null
+++ b/test/vpp_interface.py
@@ -0,0 +1,240 @@
+from abc import abstractmethod, ABCMeta
+import socket
+from logging import info, error
+from scapy.layers.l2 import Ether, ARP
+
+from scapy.layers.inet6 import IPv6, ICMPv6ND_NS, ICMPv6ND_NA, ICMPv6NDOptSrcLLAddr, ICMPv6NDOptDstLLAddr
+
+
+class VppInterface(object):
+    """
+    Generic VPP interface
+    """
+    __metaclass__ = ABCMeta
+
+    @property
+    def sw_if_index(self):
+        """Interface index assigned by VPP"""
+        return self._sw_if_index
+
+    @property
+    def remote_mac(self):
+        """MAC-address of the remote interface "connected" to this interface"""
+        return self._remote_mac
+
+    @property
+    def local_mac(self):
+        """MAC-address of the VPP interface"""
+        return self._local_mac
+
+    @property
+    def local_ip4(self):
+        """Local IPv4 address on VPP interface (string)"""
+        return self._local_ip4
+
+    @property
+    def local_ip4n(self):
+        """Local IPv4 address - raw, suitable as API parameter"""
+        return self._local_ip4n
+
+    @property
+    def remote_ip4(self):
+        """IPv4 address of remote peer "connected" to this interface"""
+        return self._remote_ip4
+
+    @property
+    def remote_ip4n(self):
+        """IPv4 address of remote peer - raw, suitable as API parameter"""
+        return self._remote_ip4n
+
+    @property
+    def local_ip6(self):
+        """Local IPv6 address on VPP interface (string)"""
+        return self._local_ip6
+
+    @property
+    def local_ip6n(self):
+        """Local IPv6 address - raw, suitable as API parameter"""
+        return self._local_ip6n
+
+    @property
+    def remote_ip6(self):
+        """IPv6 address of remote peer "connected" to this interface"""
+        return self._remote_ip6
+
+    @property
+    def remote_ip6n(self):
+        """IPv6 address of remote peer - raw, suitable as API parameter"""
+        return self._remote_ip6n
+
+    @property
+    def name(self):
+        """Name of the interface"""
+        return self._name
+
+    @property
+    def dump(self):
+        """Raw result of sw_interface_dump for this interface"""
+        return self._dump
+
+    @property
+    def test(self):
+        """Test case creating this interface"""
+        return self._test
+
+    def post_init_setup(self):
+        """Additional setup run after creating an interface object"""
+        self._remote_mac = "02:00:00:00:ff:%02x" % self.sw_if_index
+
+        self._local_ip4 = "172.16.%u.1" % self.sw_if_index
+        self._local_ip4n = socket.inet_pton(socket.AF_INET, self.local_ip4)
+        self._remote_ip4 = "172.16.%u.2" % self.sw_if_index
+        self._remote_ip4n = socket.inet_pton(socket.AF_INET, self.remote_ip4)
+
+        self._local_ip6 = "fd01:%u::1" % self.sw_if_index
+        self._local_ip6n = socket.inet_pton(socket.AF_INET6, self.local_ip6)
+        self._remote_ip6 = "fd01:%u::2" % self.sw_if_index
+        self._remote_ip6n = socket.inet_pton(socket.AF_INET6, self.remote_ip6)
+
+        r = self.test.vapi.sw_interface_dump()
+        for intf in r:
+            if intf.sw_if_index == self.sw_if_index:
+                self._name = intf.interface_name.split(b'\0', 1)[0]
+                self._local_mac = ':'.join(intf.l2_address.encode('hex')[i:i + 2]
+                                           for i in range(0, 12, 2))
+                self._dump = intf
+                break
+        else:
+            raise Exception(
+                "Could not find interface with sw_if_index %d "
+                "in interface dump %s" %
+                (self.sw_if_index, repr(r)))
+
+    @abstractmethod
+    def __init__(self, test, index):
+        self._test = test
+        self.post_init_setup()
+        info("New %s, MAC=%s, remote_ip4=%s, local_ip4=%s" %
+             (self.__name__, self.remote_mac, self.remote_ip4, self.local_ip4))
+
+    def config_ip4(self):
+        """Configure IPv4 address on the VPP interface"""
+        addr = self.local_ip4n
+        addr_len = 24
+        self.test.vapi.sw_interface_add_del_address(
+            self.sw_if_index, addr, addr_len)
+
+    def config_ip6(self):
+        """Configure IPv6 address on the VPP interface"""
+        addr = self._local_ip6n
+        addr_len = 64
+        self.test.vapi.sw_interface_add_del_address(
+            self.sw_if_index, addr, addr_len, is_ipv6=1)
+
+    def disable_ipv6_ra(self):
+        """Configure IPv6 RA suppress on the VPP interface"""
+        self.test.vapi.sw_interface_ra_suppress(self.sw_if_index)
+
+    def create_arp_req(self):
+        """Create ARP request applicable for this interface"""
+        return (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.remote_mac) /
+                ARP(op=ARP.who_has, pdst=self.local_ip4,
+                    psrc=self.remote_ip4, hwsrc=self.remote_mac))
+
+    def create_ndp_req(self):
+        return (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.remote_mac) /
+              IPv6(src=self.remote_ip6, dst=self.local_ip6) /
+              ICMPv6ND_NS(tgt=self.local_ip6) /
+              ICMPv6NDOptSrcLLAddr(lladdr=self.remote_mac))
+
+    def resolve_arp(self, pg_interface=None):
+        """Resolve ARP using provided packet-generator interface
+
+        :param pg_interface: interface used to resolve, if None then this
+            interface is used
+
+        """
+        if pg_interface is None:
+            pg_interface = self
+        info("Sending ARP request for %s on port %s" %
+             (self.local_ip4, pg_interface.name))
+        arp_req = self.create_arp_req()
+        pg_interface.add_stream(arp_req)
+        pg_interface.enable_capture()
+        self.test.pg_start()
+        info(self.test.vapi.cli("show trace"))
+        arp_reply = pg_interface.get_capture()
+        if arp_reply is None or len(arp_reply) == 0:
+            info("No ARP received on port %s" % pg_interface.name)
+            return
+        arp_reply = arp_reply[0]
+        # Make Dot1AD packet content recognizable to scapy
+        if arp_reply.type == 0x88a8:
+            arp_reply.type = 0x8100
+            arp_reply = Ether(str(arp_reply))
+        try:
+            if arp_reply[ARP].op == ARP.is_at:
+                info("VPP %s MAC address is %s " %
+                     (self.name, arp_reply[ARP].hwsrc))
+                self._local_mac = arp_reply[ARP].hwsrc
+            else:
+                info("No ARP received on port %s" % pg_interface.name)
+        except:
+            error("Unexpected response to ARP request:")
+            error(arp_reply.show())
+            raise
+
+    def resolve_ndp(self, pg_interface=None):
+        """Resolve NDP using provided packet-generator interface
+
+        :param pg_interface: interface used to resolve, if None then this
+            interface is used
+
+        """
+        if pg_interface is None:
+            pg_interface = self
+        info("Sending NDP request for %s on port %s" %
+             (self.local_ip6, pg_interface.name))
+        ndp_req = self.create_ndp_req()
+        pg_interface.add_stream(ndp_req)
+        pg_interface.enable_capture()
+        self.test.pg_start()
+        info(self.test.vapi.cli("show trace"))
+        ndp_reply = pg_interface.get_capture()
+        if ndp_reply is None or len(ndp_reply) == 0:
+            info("No NDP received on port %s" % pg_interface.name)
+            return
+        ndp_reply = ndp_reply[0]
+        # Make Dot1AD packet content recognizable to scapy
+        if ndp_reply.type == 0x88a8:
+            ndp_reply.type = 0x8100
+            ndp_reply = Ether(str(ndp_reply))
+        try:
+            ndp_na = ndp_reply[ICMPv6ND_NA]
+            opt = ndp_na[ICMPv6NDOptDstLLAddr]
+            info("VPP %s MAC address is %s " %
+                 (self.name, opt.lladdr))
+            self._local_mac = opt.lladdr
+        except:
+            error("Unexpected response to NDP request:")
+            error(ndp_reply.show())
+            raise
+
+    def admin_up(self):
+        """ Put interface ADMIN-UP """
+        self.test.vapi.sw_interface_set_flags(self.sw_if_index, admin_up_down=1)
+
+    def add_sub_if(self, sub_if):
+        """
+        Register a sub-interface with this interface
+
+        :param sub_if: sub-interface
+
+        """
+        if not hasattr(self, 'sub_if'):
+            self.sub_if = sub_if
+        else:
+            if isinstance(self.sub_if, list):
+                self.sub_if.append(sub_if)
+            else:
+                self.sub_if = sub_if
diff --git a/test/vpp_papi_provider.py b/test/vpp_papi_provider.py
new file mode 100644
index 00000000..b83cd43f
--- /dev/null
+++ b/test/vpp_papi_provider.py
@@ -0,0 +1,316 @@
+import vpp_papi
+from logging import error
+from hook import Hook
+
+# from vnet/vnet/mpls/mpls_types.h
+MPLS_IETF_MAX_LABEL = 0xfffff
+MPLS_LABEL_INVALID = MPLS_IETF_MAX_LABEL + 1
+
+
+class VppPapiProvider(object):
+    """VPP-api provider using vpp-papi
+
+    @property hook: hook object providing before and after api/cli hooks
+
+
+    """
+
+    def __init__(self, name, shm_prefix):
+        self.hook = Hook()
+        self.name = name
+        self.shm_prefix = shm_prefix
+
+    def register_hook(self, hook):
+        """Replace hook registration with new hook
+
+        :param hook:
+
+        """
+        self.hook = hook
+
+    def connect(self):
+        """Connect the API to VPP"""
+        vpp_papi.connect(self.name, self.shm_prefix)
+
+    def disconnect(self):
+        """Disconnect the API from VPP"""
+        vpp_papi.disconnect()
+
+    def api(self, api_fn, api_args, expected_retval=0):
+        """Call API function and check it's return value
+        Call the appropriate hooks before and after the API call
+
+        :param api_fn: API function to call
+        :param api_args: tuple of API function arguments
+        :param expected_retval: Expected return value (Default value = 0)
+        :returns: reply from the API
+
+        """
+        self.hook.before_api(api_fn.__name__, api_args)
+        reply = api_fn(*api_args)
+        if hasattr(reply, 'retval') and reply.retval != expected_retval:
+            msg = "API call failed, expected retval == %d, got %s" % (
+                expected_retval, repr(reply))
+            error(msg)
+            raise Exception(msg)
+        self.hook.after_api(api_fn.__name__, api_args)
+        return reply
+
+    def cli(self, cli):
+        """Execute a CLI, calling the before/after hooks appropriately
+
+        :param cli: CLI to execute
+        :returns: CLI output
+
+        """
+        self.hook.before_cli(cli)
+        cli += '\n'
+        r = vpp_papi.cli_inband(len(cli), cli)
+        self.hook.after_cli(cli)
+        if(hasattr(r, 'reply')):
+            return r.reply[0].decode().rstrip('\x00')
+
+    def show_version(self):
+        """ """
+        return vpp_papi.show_version()
+
+    def pg_create_interface(self, pg_index):
+        """
+
+        :param pg_index:
+
+        """
+        return self.api(vpp_papi.pg_create_interface, (pg_index, ))
+
+    def sw_interface_dump(self, filter=None):
+        """
+
+        :param filter:  (Default value = None)
+
+        """
+        if filter is not None:
+            args = (1, filter)
+        else:
+            args = (0, b'')
+        return self.api(vpp_papi.sw_interface_dump, args)
+
+    def sw_interface_add_del_address(self, sw_if_index, addr, addr_len,
+                                     is_ipv6=0, is_add=1, del_all=0):
+        """
+
+        :param addr: param is_ipv6:  (Default value = 0)
+        :param sw_if_index:
+        :param addr_len:
+        :param is_ipv6:  (Default value = 0)
+        :param is_add:  (Default value = 1)
+        :param del_all:  (Default value = 0)
+
+        """
+        return self.api(vpp_papi.sw_interface_add_del_address,
+                        (sw_if_index, is_add, is_ipv6, del_all, addr_len, addr))
+
+    def sw_interface_ra_suppress(self, sw_if_index):
+        suppress = 1
+        managed = 0
+        other = 0
+        ll_option = 0
+        send_unicast = 0
+        cease = 0
+        is_no = 0
+        default_router = 0
+        max_interval = 0
+        min_interval = 0
+        lifetime = 0
+        initial_count = 0
+        initial_interval = 0
+        async = False
+        return self.api(vpp_papi.sw_interface_ip6nd_ra_config,
+                        (sw_if_index, suppress, managed, other,
+                         ll_option, send_unicast, cease, is_no,
+                         default_router, max_interval, min_interval,
+                         lifetime, initial_count, initial_interval, async))
+
+
+    def vxlan_add_del_tunnel(
+            self,
+            src_addr,
+            dst_addr,
+            is_add=1,
+            is_ipv6=0,
+            encap_vrf_id=0,
+            decap_next_index=0xFFFFFFFF,
+            vni=0):
+        """
+
+        :param dst_addr:
+        :param src_addr:
+        :param is_add:  (Default value = 1)
+        :param is_ipv6:  (Default value = 0)
+        :param encap_vrf_id:  (Default value = 0)
+        :param decap_next_index:  (Default value = 0xFFFFFFFF)
+        :param vni:  (Default value = 0)
+
+        """
+        return self.api(vpp_papi.vxlan_add_del_tunnel,
+                        (is_add, is_ipv6, src_addr, dst_addr, encap_vrf_id,
+                         decap_next_index, vni))
+
+    def sw_interface_set_l2_bridge(self, sw_if_index, bd_id,
+                                   shg=0, bvi=0, enable=1):
+        """
+
+        :param bd_id:
+        :param sw_if_index:
+        :param shg:  (Default value = 0)
+        :param bvi:  (Default value = 0)
+        :param enable:  (Default value = 1)
+
+        """
+        return self.api(vpp_papi.sw_interface_set_l2_bridge,
+                        (sw_if_index, bd_id, shg, bvi, enable))
+
+    def sw_interface_set_l2_xconnect(self, rx_sw_if_index, tx_sw_if_index,
+                                     enable):
+        """Create or delete unidirectional cross-connect from Tx interface to
+        Rx interface.
+
+        :param rx_sw_if_index: Software interface index of Rx interface.
+        :param tx_sw_if_index: Software interface index of Tx interface.
+        :param enable: Create cross-connect if equal to 1, delete cross-connect
+        if equal to 0.
+        :type rx_sw_if_index: str or int
+        :type rx_sw_if_index: str or int
+        :type enable: int
+
+        """
+        return self.api(vpp_papi.sw_interface_set_l2_xconnect,
+                        (rx_sw_if_index, tx_sw_if_index, enable))
+
+    def sw_interface_set_flags(self, sw_if_index, admin_up_down,
+                               link_up_down=0, deleted=0):
+        """
+
+        :param admin_up_down:
+        :param sw_if_index:
+        :param link_up_down:  (Default value = 0)
+        :param deleted:  (Default value = 0)
+
+        """
+        return self.api(vpp_papi.sw_interface_set_flags,
+                        (sw_if_index, admin_up_down, link_up_down, deleted))
+
+    def create_subif(self, sw_if_index, sub_id, outer_vlan, inner_vlan,
+                     no_tags=0, one_tag=0, two_tags=0, dot1ad=0, exact_match=0,
+                     default_sub=0, outer_vlan_id_any=0, inner_vlan_id_any=0):
+        """Create subinterface
+        from vpe.api: set dot1ad = 0 for dot1q, set dot1ad = 1 for dot1ad
+
+        :param sub_id: param inner_vlan:
+        :param sw_if_index:
+        :param outer_vlan:
+        :param inner_vlan:
+        :param no_tags:  (Default value = 0)
+        :param one_tag:  (Default value = 0)
+        :param two_tags:  (Default value = 0)
+        :param dot1ad:  (Default value = 0)
+        :param exact_match:  (Default value = 0)
+        :param default_sub:  (Default value = 0)
+        :param outer_vlan_id_any:  (Default value = 0)
+        :param inner_vlan_id_any:  (Default value = 0)
+
+        """
+        return self.api(
+            vpp_papi.create_subif,
+            (sw_if_index,
+             sub_id,
+             no_tags,
+             one_tag,
+             two_tags,
+             dot1ad,
+             exact_match,
+             default_sub,
+             outer_vlan_id_any,
+             inner_vlan_id_any,
+             outer_vlan,
+             inner_vlan))
+
+    def create_vlan_subif(self, sw_if_index, vlan):
+        """
+
+        :param vlan:
+        :param sw_if_index:
+
+        """
+        return self.api(vpp_papi.create_vlan_subif, (sw_if_index, vlan))
+
+    def ip_add_del_route(
+            self,
+            dst_address,
+            dst_address_length,
+            next_hop_address,
+            next_hop_sw_if_index=0xFFFFFFFF,
+            table_id=0,
+            resolve_attempts=0,
+            classify_table_index=0xFFFFFFFF,
+            next_hop_out_label=MPLS_LABEL_INVALID,
+            next_hop_table_id=0,
+            create_vrf_if_needed=0,
+            resolve_if_needed=0,
+            is_add=1,
+            is_drop=0,
+            is_ipv6=0,
+            is_local=0,
+            is_classify=0,
+            is_multipath=0,
+            is_resolve_host=0,
+            is_resolve_attached=0,
+            not_last=0,
+            next_hop_weight=1):
+        """
+
+        :param dst_address_length:
+        :param next_hop_sw_if_index:  (Default value = 0xFFFFFFFF)
+        :param dst_address:
+        :param next_hop_address:
+        :param next_hop_sw_if_index:  (Default value = 0xFFFFFFFF)
+        :param vrf_id:  (Default value = 0)
+        :param lookup_in_vrf:  (Default value = 0)
+        :param resolve_attempts:  (Default value = 0)
+        :param classify_table_index:  (Default value = 0xFFFFFFFF)
+        :param create_vrf_if_needed:  (Default value = 0)
+        :param resolve_if_needed:  (Default value = 0)
+        :param is_add:  (Default value = 1)
+        :param is_drop:  (Default value = 0)
+        :param is_ipv6:  (Default value = 0)
+        :param is_local:  (Default value = 0)
+        :param is_classify:  (Default value = 0)
+        :param is_multipath:  (Default value = 0)
+        :param is_resolve_host:  (Default value = 0)
+        :param is_resolve_attached:  (Default value = 0)
+        :param not_last:  (Default value = 0)
+        :param next_hop_weight:  (Default value = 1)
+
+        """
+        return self.api(
+            vpp_papi.ip_add_del_route,
+            (next_hop_sw_if_index,
+             table_id,
+             resolve_attempts,
+             classify_table_index,
+             next_hop_out_label,
+             next_hop_table_id,
+             create_vrf_if_needed,
+             resolve_if_needed,
+             is_add,
+             is_drop,
+             is_ipv6,
+             is_local,
+             is_classify,
+             is_multipath,
+             is_resolve_host,
+             is_resolve_attached,
+             not_last,
+             next_hop_weight,
+             dst_address_length,
+             dst_address,
+             next_hop_address))
diff --git a/test/vpp_pg_interface.py b/test/vpp_pg_interface.py
new file mode 100644
index 00000000..fc4080d2
--- /dev/null
+++ b/test/vpp_pg_interface.py
@@ -0,0 +1,99 @@
+import os
+from logging import error
+from scapy.utils import wrpcap, rdpcap
+from vpp_interface import VppInterface
+
+
+class VppPGInterface(VppInterface):
+    """
+    VPP packet-generator interface
+    """
+
+    @property
+    def pg_index(self):
+        """packet-generator interface index assigned by VPP"""
+        return self._pg_index
+
+    @property
+    def out_path(self):
+        """pcap file path - captured packets"""
+        return self._out_path
+
+    @property
+    def in_path(self):
+        """ pcap file path - injected packets"""
+        return self._in_path
+
+    @property
+    def capture_cli(self):
+        """CLI string to start capture on this interface"""
+        return self._capture_cli
+
+    @property
+    def cap_name(self):
+        """capture name for this interface"""
+        return self._cap_name
+
+    @property
+    def input_cli(self):
+        """CLI string to load the injected packets"""
+        return self._input_cli
+
+    def post_init_setup(self):
+        """ Perform post-init setup for super class and add our own setup """
+        super(VppPGInterface, self).post_init_setup()
+        self._out_path = self.test.tempdir + "/pg%u_out.pcap" % self.sw_if_index
+        self._in_path = self.test.tempdir + "/pg%u_in.pcap" % self.sw_if_index
+        self._capture_cli = "packet-generator capture pg%u pcap %s" % (
+            self.pg_index, self.out_path)
+        self._cap_name = "pcap%u" % self.sw_if_index
+        self._input_cli = "packet-generator new pcap %s source pg%u name %s" % (
+            self.in_path, self.pg_index, self.cap_name)
+
+    def __init__(self, test, pg_index):
+        """ Create VPP packet-generator interface """
+        self._pg_index = pg_index
+        self._test = test
+        r = self.test.vapi.pg_create_interface(self.pg_index)
+        self._sw_if_index = r.sw_if_index
+        self.post_init_setup()
+
+    def enable_capture(self):
+        """ Enable capture on this packet-generator interface"""
+        try:
+            os.unlink(self.out_path)
+        except:
+            pass
+        # FIXME this should be an API, but no such exists atm
+        self.test.vapi.cli(self.capture_cli)
+
+    def add_stream(self, pkts):
+        """
+        Add a stream of packets to this packet-generator
+
+        :param pkts: iterable packets
+
+        """
+        try:
+            os.remove(self.in_path)
+        except:
+            pass
+        wrpcap(self.in_path, pkts)
+        # FIXME this should be an API, but no such exists atm
+        self.test.vapi.cli(self.input_cli)
+        self.test.pg_streams.append(self.cap_name)
+        self.test.vapi.cli("trace add pg-input %d" % len(pkts))
+
+    def get_capture(self):
+        """
+        Get captured packets
+
+        :returns: iterable packets
+        """
+        try:
+            output = rdpcap(self.out_path)
+        except IOError:  # TODO
+            error("File %s does not exist, probably because no"
+                  " packets arrived" % self.out_path)
+            return []
+        return output
diff --git a/test/vpp_sub_interface.py b/test/vpp_sub_interface.py
new file mode 100644
index 00000000..cd98a68c
--- /dev/null
+++ b/test/vpp_sub_interface.py
@@ -0,0 +1,143 @@
+from scapy.layers.l2 import Ether, Dot1Q
+from abc import abstractmethod, ABCMeta
+from vpp_interface import VppInterface
+
+
+class VppSubInterface(VppInterface):
+    __metaclass__ = ABCMeta
+
+    @property
+    def parent(self):
+        """Parent interface for this sub-interface"""
+        return self._parent
+
+    @property
+    def sub_id(self):
+        """Sub-interface ID"""
+        return self._sub_id
+
+    def __init__(self, test, parent, sub_id):
+        self._test = test
+        self._parent = parent
+        self._parent.add_sub_if(self)
+        self._sub_id = sub_id
+
+    @abstractmethod
+    def create_arp_req(self):
+        pass
+
+    @abstractmethod
+    def create_ndp_req(self):
+        pass
+
+    def resolve_arp(self):
+        super(VppSubInterface, self).resolve_arp(self.parent)
+
+    def resolve_ndp(self):
+        super(VppSubInterface, self).resolve_ndp(self.parent)
+
+    @abstractmethod
+    def add_dot1_layer(self, pkt):
+        pass
+
+
+class VppDot1QSubint(VppSubInterface):
+
+    @property
+    def vlan(self):
+        """VLAN tag"""
+        return self._vlan
+
+    def __init__(self, test, parent, sub_id, vlan=None):
+        if vlan is None:
+            vlan = sub_id
+        super(VppDot1QSubint, self).__init__(test, parent, sub_id)
+        self._vlan = vlan
+        r = self.test.vapi.create_vlan_subif(parent.sw_if_index, self.vlan)
+        self._sw_if_index = r.sw_if_index
+        self.post_init_setup()
+
+    def create_arp_req(self):
+        packet = VppInterface.create_arp_req(self)
+        return self.add_dot1_layer(packet)
+
+    def create_ndp_req(self):
+        packet = VppInterface.create_ndp_req(self)
+        return self.add_dot1_layer(packet)
+
+    def add_dot1_layer(self, packet):
+        payload = packet.payload
+        packet.remove_payload()
+        packet.add_payload(Dot1Q(vlan=self.sub_id) / payload)
+        return packet
+
+    def remove_dot1_layer(self, packet):
+        payload = packet.payload
+        self.test.instance().assertEqual(type(payload), Dot1Q)
+        self.test.instance().assertEqual(payload.vlan, self.vlan)
+        payload = payload.payload
+        packet.remove_payload()
+        packet.add_payload(payload)
+        return packet
+
+
+class VppDot1ADSubint(VppSubInterface):
+
+    @property
+    def outer_vlan(self):
+        """Outer VLAN tag"""
+        return self._outer_vlan
+
+    @property
+    def inner_vlan(self):
+        """Inner VLAN tag"""
+        return self._inner_vlan
+
+    def __init__(self, test, parent, sub_id, outer_vlan, inner_vlan):
+        super(VppDot1ADSubint, self).__init__(test, parent, sub_id)
+        self.DOT1AD_TYPE = 0x88A8
+        self.DOT1Q_TYPE = 0x8100
+        self._outer_vlan = outer_vlan
+        self._inner_vlan = inner_vlan
+        r = self.test.vapi.create_subif(
+            parent.sw_if_index,
+            self.sub_id,
+            self.outer_vlan,
+            self.inner_vlan,
+            dot1ad=1,
+            two_tags=1,
+            exact_match=1)
+        self._sw_if_index = r.sw_if_index
+        self.post_init_setup()
+
+    def create_arp_req(self):
+        packet = VppInterface.create_arp_req(self)
+        return self.add_dot1_layer(packet)
+
+    def create_ndp_req(self):
+        packet = VppInterface.create_ndp_req(self)
+        return self.add_dot1_layer(packet)
+
+    def add_dot1_layer(self, packet):
+        payload = packet.payload
+        packet.remove_payload()
+        packet.add_payload(Dot1Q(vlan=self.outer_vlan) /
+                           Dot1Q(vlan=self.inner_vlan) / payload)
+        packet.type = self.DOT1AD_TYPE
+        return packet
+
+    def remove_dot1_layer(self, packet):
+        self.test.instance().assertEqual(type(packet), Ether)
+        self.test.instance().assertEqual(packet.type, self.DOT1AD_TYPE)
+        packet.type = self.DOT1Q_TYPE
+        packet = Ether(str(packet))
+        payload = packet.payload
+        self.test.instance().assertEqual(type(payload), Dot1Q)
+        self.test.instance().assertEqual(payload.vlan, self.outer_vlan)
+        payload = payload.payload
+        self.test.instance().assertEqual(type(payload), Dot1Q)
+        self.test.instance().assertEqual(payload.vlan, self.inner_vlan)
+        payload = payload.payload
+        packet.remove_payload()
+        packet.add_payload(payload)
+        return packet