diff --git a/TestON/bin/.pylint b/TestON/bin/.pylint
new file mode 100644
index 0000000..469a744
--- /dev/null
+++ b/TestON/bin/.pylint
@@ -0,0 +1,300 @@
+# lint Python modules using external checkers.
+#
+# This is the main checker controlling the other ones and the reports
+# generation. It is itself both a raw checker and an astng checker in order
+# to:
+# * handle message activation / deactivation at the module level
+# * handle some basic but necessary stats'data (number of classes, methods...)
+#
+[MASTER]
+
+# Specify a configuration file.
+#rcfile=
+
+# Python code to execute, usually for sys.path manipulation such as
+# pygtk.require().
+#init-hook=
+
+# Profiled execution.
+profile=no
+
+# Add <file or directory> to the black list. It should be a base name, not a
+# path. You may set this option multiple times.
+ignore=CVS
+
+# Pickle collected data for later comparisons.
+persistent=yes
+
+# List of plugins (as comma separated values of python modules names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+
+[MESSAGES CONTROL]
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time.
+#enable=
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifier separated by comma (,) or put this option
+# multiple time (only on the command line, not in the configuration file where
+# it should appear only once).
+disable=pointless-except, invalid-name, super-init-not-called, fixme, star-args,
+        too-many-instance-attributes, too-few-public-methods, too-many-arguments,
+        too-many-locals, too-many-public-methods, duplicate-code, bad-whitespace,
+        locally-disabled
+
+[REPORTS]
+
+# Set the output format. Available formats are text, parseable, colorized, msvs
+# (visual studio) and html
+output-format=colorized
+msg-template='{path}:{line}: [{msg_id}({symbol}), {obj}] {msg}'
+
+# Include message's id in output
+include-ids=yes
+
+# Put messages in a separate file for each module / package specified on the
+# command line instead of printing them on stdout. Reports (if any) will be
+# written in a file name "pylint_global.[txt|html]".
+files-output=no
+
+# Tells wether to display a full report or only the messages
+reports=no
+
+# Python expression which should return a note less than 10 (10 is the highes
+# note). You have access to the variables errors warning, statement which
+# respectivly contain the number of errors / warnings messages and the total
+# number of statements analyzed. This is used by the global evaluation repor
+# (R0004).
+evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
+
+# Add a comment according to your evaluation note. This is used by the global
+# evaluation report (R0004).
+comment=no
+
+# Enable the report(s) with the given id(s).
+#enable-report=
+
+# Disable the report(s) with the given id(s).
+#disable-report=
+
+
+# checks for :
+# * doc strings
+# * modules / classes / functions / methods / arguments / variables name
+# * number of arguments, local variables, branchs, returns and statements in
+# functions, methods
+# * required module attributes
+# * dangerous default values as arguments
+# * redefinition of function / method / class
+# * uses of the global statemen
+#
+[BASIC]
+
+# Required attributes for module, separated by a comma
+required-attributes=
+
+# Regular expression which should only match functions or classes name which do
+# not require a docstring
+no-docstring-rgx=__.*__
+
+# Regular expression which should only match correct module names
+module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
+
+# Regular expression which should only match correct module level names
+const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$
+
+# Regular expression which should only match correct class names
+class-rgx=[A-Z_][a-zA-Z0-9]+$
+
+# Regular expression which should only match correct function names
+function-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression which should only match correct method names
+method-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression which should only match correct instance attribute names
+attr-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression which should only match correct argument names
+argument-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression which should only match correct variable names
+variable-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression which should only match correct list comprehension /
+# generator expression variable names
+inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$
+
+# Good variable names which should always be accepted, separated by a comma
+good-names=i,j,k,ex,Run,_
+
+# Bad variable names which should always be refused, separated by a comma
+bad-names=foo,bar,baz,toto,tutu,tata
+
+# List of builtins function names that should not be used, separated by a comma
+bad-functions=map,filter,apply,inpu
+
+
+# try to find bugs in the code using type inference
+#
+[TYPECHECK]
+
+# Tells wether missing members accessed in mixin class should be ignored. A
+# mixin class is detected if its name ends with "mixin" (case insensitive).
+ignore-mixin-members=yes
+
+# List of classes names for which member attributes should not be checked
+# (useful for classes with attributes dynamicaly set).
+ignored-classes=SQLObjec
+
+# When zope mode is activated, add a predefined set of Zope acquired attributes
+# to generated-members.
+zope=no
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E0201 when accessed.
+generated-members=REQUEST,acl_users,aq_paren
+
+
+# checks for
+# * unused variables / imports
+# * undefined variables
+# * redefinition of variable from builtins or from an outer scope
+# * use of variable before assigmen
+#
+[VARIABLES]
+
+# Tells wether we should check for unused import in __init__ files.
+init-import=no
+
+# A regular expression matching names used for dummy variables (i.e. not used).
+dummy-variables-rgx=_|dummy
+
+# List of additional names supposed to be defined in builtins. Remember tha
+# you should avoid to define new builtins when possible.
+additional-builtins=
+
+
+# checks for :
+# * methods without self as first argumen
+# * overridden methods signature
+# * access only to existant members via self
+# * attributes not defined in the __init__ method
+# * supported interfaces implementation
+# * unreachable code
+#
+[CLASSES]
+
+# List of interface methods to ignore, separated by a comma. This is used for
+# instance to not check methods defines in Zope's Interface base class.
+ignore-iface-methods=isImplementedBy,deferred,extends,names,namesAndDescriptions,queryDescriptionFor,getBases,getDescriptionFor,getDoc,getName,getTaggedValue,getTaggedValueTags,isEqualOrExtendedBy,setTaggedValue,isImplementedByInstancesOf,adaptWith,is_implemented_by
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,__new__,setUp,build
+
+
+# checks for sign of poor/misdesign:
+# * number of methods, attributes, local variables...
+# * size, complexity of functions, methods
+#
+[DESIGN]
+
+# Maximum number of arguments for function / method
+max-args=5
+
+# Maximum number of locals for function / method body
+max-locals=15
+
+# Maximum number of return / yield for function / method body
+max-returns=6
+
+# Maximum number of branch for function / method body
+max-branchs=12
+
+# Maximum number of statements in function / method body
+max-statements=50
+
+# Maximum number of parents for a class (see R0901).
+max-parents=7
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=7
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=2
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=20
+
+
+# checks for
+# * external modules dependencies
+# * relative / wildcard imports
+# * cyclic imports
+# * uses of deprecated modules
+#
+[IMPORTS]
+
+# Deprecated modules which should not be used, separated by a comma
+deprecated-modules=regsub,string,TERMIOS,Bastion,rexec
+
+# Create a graph of every (i.e. internal and external) dependencies in the
+# given file (report R0402 must not be disabled)
+import-graph=
+
+# Create a graph of external dependencies in the given file (report R0402 mus
+# not be disabled)
+ext-import-graph=
+
+# Create a graph of internal dependencies in the given file (report R0402 mus
+# not be disabled)
+int-import-graph=
+
+
+# checks for :
+# * unauthorized constructions
+# * strict indentation
+# * line length
+# * use of <> instead of !=
+#
+[FORMAT]
+
+# Maximum number of characters on a single line.
+max-line-length=80
+
+# Maximum number of lines in a module
+max-module-lines=1500
+
+# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1
+# tab).
+indent-string='    '
+
+
+# checks for:
+# * warning notes in the code like FIXME, XXX
+# * PEP 263: source code with non ascii character but no encoding declaration
+#
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=FIXME,XXX,TODO
+
+
+# checks for similarities and duplicated code. This computation may be
+# memory / CPU intensive, so you should disable it if you experiments some
+# problems.
+#
+[SIMILARITIES]
+
+# Minimum lines number of a similarity.
+min-similarity-lines=4
+
+# Ignore comments when computing similarities.
+ignore-comments=yes
+
+# Ignore docstrings when computing similarities.
+ignore-docstrings=yes
diff --git a/TestON/bin/codecheck b/TestON/bin/codecheck
new file mode 100755
index 0000000..1193df8
--- /dev/null
+++ b/TestON/bin/codecheck
@@ -0,0 +1,50 @@
+#!/bin/bash
+
+#These are from the Mininet coding style
+P8IGN=E251,E201,E302,E202,E126,E127,E203,E226,W391
+
+# help text function
+help ()
+{
+    echo "Usage: codecheck [FILE]... [OPTION]..."
+    echo "Simple script that runs some python code check tools on a file or folder"
+    echo "Note that for now, options must come after the file/folder path"
+    echo -e "\nOptions include:"
+    echo -e "   --fix\tRun the automatic style scripts on a file and save the output to FILE.fixed"
+    echo -e "   --reason\tShow a short snippit for each PEP8 violation"
+    echo -e "   --help\tDisplays this help text and exits"
+}
+
+
+if [ -z "$1" ] || [[ "$1" =~ --* ]]; then
+    help
+elif [ "$2" = "--fix" ]; then
+    file=$1.fixed
+    echo "Fixing PEP8 errors. WARNING: This may be harmful to your code."
+    echo "For safety, the new code is written to $file"
+    #autopep8 -a -a $1
+    autopep8 -a -a $1 --ignore=E501 | $(dirname "${BASH_SOURCE}")/unpep8 > $file
+    autopep8 --in-place -a -a $file --ignore=$P8IGN
+elif [ -z "$2" ] || [ "$2" = "--reason" ]; then
+    echo "Running pyflakes..."
+    #Pyflakes is a source checker. It doesn't run the code so it is safer than other programs
+    #ignoring some errors due to TestON
+    pyflakes $1 | grep -v "undefined name 'main'" | grep -v "undefined name 'utilities'"
+    echo "Running pylint..."
+    #Pylint is a static code checker
+    #ignoring some errors due to TestON
+    pylint -E --rcfile=$(dirname "${BASH_SOURCE}")/.pylint $1 | grep -v "Undefined variable 'main'" | grep -v "Undefined variable 'utilities'"
+
+    echo "Running PEP8..."
+    #PEP8 is a the most common python coding style standard
+    if [ -z "$2"]; then
+        pep8 --repeat --show-source --ignore=$P8IGN $1
+    else
+        pep8 --repeat --show-source --show-pep8 --ignore=$P8IGN $1
+    fi
+else
+    help
+fi
+
+
+
diff --git a/TestON/bin/unpep8 b/TestON/bin/unpep8
new file mode 100755
index 0000000..090865a
--- /dev/null
+++ b/TestON/bin/unpep8
@@ -0,0 +1,198 @@
+#!/usr/bin/python
+
+"""
+Translate from PEP8 Python style to Mininet (i.e. Arista-like)
+Python style
+
+usage: unpep8 < old.py > new.py
+
+- Reinstates CapWords for methods and instance variables
+- Gets rid of triple single quotes
+- Eliminates triple quotes on single lines
+- Inserts extra spaces to improve readability
+- Fixes Doxygen (or doxypy) ugliness
+
+Does the following translations:
+
+ClassName.method_name(foo = bar) -> ClassName.methodName( foo=bar )
+
+Triple-single-quotes -> triple-double-quotes
+
+@param foo description -> foo: description
+@return description    -> returns: description
+@author me             -> author: me
+@todo(me)              -> TODO(me)
+
+Bugs/Limitations:
+
+- Hack to restore strings is ugly
+- Multiline strings get mangled
+- Comments are mangled (which is arguably the "right thing" to do, except
+  that, for example, the left hand sides of the above would get translated!)
+- Doesn't eliminate unnecessary backslashes
+- Has no opinion on tab size
+- complicated indented docstrings get flattened
+- We don't (yet) have a filter to generate Doxygen/Doxypy
+- Currently leaves indents on blank comment lines
+- May lead to namespace collisions (e.g. some_thing and someThing)
+
+Bob Lantz, rlantz@cs.stanford.edu
+1/24/2010
+"""
+
+import re, sys
+
+def fixUnderscoreTriplet( match ):
+   "Translate a matched triplet of the form a_b to aB."
+   triplet = match.group()
+   return triplet[ :-2 ] + triplet[ -1 ].capitalize()
+
+def reinstateCapWords( text ):
+   underscoreTriplet = re.compile( r'[A-Za-z0-9]_[A-Za-z0-9]' )
+   return underscoreTriplet.sub( fixUnderscoreTriplet, text )
+ 
+def replaceTripleApostrophes( text ):
+   "Replace triple apostrophes with triple quotes."
+   return text.replace( "'''", '"""')
+
+def simplifyTripleQuotes( text ):
+   "Fix single-line doc strings."
+   r = re.compile( r'"""([^\"\n]+)"""' )
+   return r.sub( r'"\1"', text )
+   
+def insertExtraSpaces( text ):
+   "Insert extra spaces inside of parentheses and brackets/curly braces."
+   lparen = re.compile( r'\((?![\s\)])' )
+   text = lparen.sub( r'( ', text )
+   rparen = re.compile( r'([^\s\(])(?=\))' )
+   text = rparen.sub( r'\1 ', text)
+   # brackets
+   lbrack = re.compile( r'\[(?![\s\]])' )
+   text = lbrack.sub( r'[ ', text )
+   rbrack = re.compile( r'([^\s\[])(?=\])' )
+   text = rbrack.sub( r'\1 ', text)
+   # curly braces
+   lcurly = re.compile( r'\{(?![\s\}])' )
+   text = lcurly.sub( r'{ ', text )
+   rcurly = re.compile( r'([^\s\{])(?=\})' )
+   text = rcurly.sub( r'\1 ', text)   
+   return text
+   
+def fixDoxygen( text ):
+   """Translate @param foo to foo:, @return bar to returns: bar, and
+      @author me to author: me"""
+   param = re.compile( r'@param (\w+)' )
+   text = param.sub( r'\1:', text )
+   returns = re.compile( r'@return' )
+   text = returns.sub( r'returns:', text )
+   author = re.compile( r'@author' )
+   text = author.sub( r'author:', text)
+   # @todo -> TODO
+   text = text.replace( '@todo', 'TODO' )
+   return text
+
+def removeCommentFirstBlankLine( text ):
+   "Remove annoying blank lines after first line in comments."
+   line = re.compile( r'("""[^\n]*\n)\s*\n', re.MULTILINE )
+   return line.sub( r'\1', text )
+   
+def fixArgs( match, kwarg = re.compile( r'(\w+) = ' ) ):
+   "Replace foo = bar with foo=bar."
+   return kwarg.sub( r'\1=', match.group() )
+   
+def fixKeywords( text ):
+   "Change keyword argumentsfrom foo = bar to foo=bar."
+   args = re.compile( r'\(([^\)]+)\)', re.MULTILINE )
+   return args.sub( fixArgs, text )
+
+# Unfortunately, Python doesn't natively support balanced or recursive
+# regular expressions. We could use PyParsing, but that opens another can
+# of worms. For now, we just have a cheap hack to restore strings,
+# so we don't end up accidentally mangling things like messages, search strings,
+# and regular expressions.
+
+def lineIter( text ):
+   "Simple iterator over lines in text."
+   for line in text.splitlines(): yield line
+   
+def stringIter( strList ):
+   "Yield strings in strList."
+   for s in strList: yield s
+
+def restoreRegex( regex, old, new ):
+   "Find regexes in old and restore them into new."
+   oldStrs = regex.findall( old )
+   # Sanity check - count should be the same!
+   newStrs = regex.findall( new )
+   assert len( oldStrs ) == len( newStrs )
+   # Replace newStrs with oldStrs
+   siter = stringIter( oldStrs )
+   reps = lambda dummy: siter.next()
+   return regex.sub( reps, new )
+
+# This is a cheap hack, and it may not work 100%, since
+# it doesn't handle multiline strings.
+# However, it should be mostly harmless...
+   
+def restoreStrings( oldText, newText ):
+   "Restore strings from oldText into newText, returning result."
+   oldLines, newLines = lineIter( oldText ), lineIter( newText )
+   quoteStrings = re.compile( r'("[^"]*")' )
+   tickStrings = re.compile( r"('[^']*')" )
+   result = ''
+   # It would be nice if we could blast the whole file, but for
+   # now it seems to work line-by-line
+   for newLine in newLines:
+      oldLine = oldLines.next()
+      newLine = restoreRegex( quoteStrings, oldLine, newLine )
+      newLine = restoreRegex( tickStrings, oldLine, newLine )
+      result += newLine + '\n'
+   return result
+   
+# This might be slightly controversial, since it uses
+# three spaces to line up multiline comments. However,
+# I much prefer it. Limitations: if you have deeper
+# indents in comments, they will be eliminated. ;-(
+
+def fixComment( match, 
+   indentExp=re.compile( r'\n([ ]*)(?=[^/s])', re.MULTILINE ),
+   trailingQuotes=re.compile( r'\s+"""' ) ):
+   "Re-indent comment, and join trailing quotes."
+   originalIndent = match.group( 1 )
+   comment = match.group( 2 )
+   indent = '\n' + originalIndent
+   # Exception: leave unindented things unindented!
+   if len( originalIndent ) is not 0: indent += '   '
+   comment = indentExp.sub( indent, comment )
+   return originalIndent + trailingQuotes.sub( '"""', comment )
+   
+def fixCommentIndents( text ):
+   "Fix multiline comment indentation."
+   comments = re.compile( r'^([ ]*)("""[^"]*""")$', re.MULTILINE )
+   return comments.sub( fixComment, text )
+ 
+def removeBogusLinefeeds( text ):
+   "Remove extra linefeeds at the end of single-line comments."
+   bogusLfs = re.compile( r'"([^"\n]*)\n"', re.MULTILINE )
+   return bogusLfs.sub( '"\1"', text)
+   
+def convertFromPep8( program ):
+   oldProgram = program
+   # Program text transforms
+   # program = reinstateCapWords( program )  # Turning off for now
+   program = fixKeywords( program )
+   program = insertExtraSpaces( program )
+   # Undo string damage
+   program = restoreStrings( oldProgram, program )
+   # Docstring transforms
+   program = replaceTripleApostrophes( program )
+   program = simplifyTripleQuotes( program )
+   program = fixDoxygen( program )
+   # program = fixCommentIndents( program ) # Turning off as it breaks tests in TestON
+   program = removeBogusLinefeeds( program )
+   # Destructive transforms (these can delete lines)
+   program = removeCommentFirstBlankLine( program )
+   return program
+
+if __name__ == '__main__':
+   print convertFromPep8( sys.stdin.read() )
diff --git a/TestON/core/logger.py b/TestON/core/logger.py
index 3a24008..80fe0de 100644
--- a/TestON/core/logger.py
+++ b/TestON/core/logger.py
@@ -110,7 +110,7 @@
            
         main.LogFileName = main.logdir + "/" + main.TEST + "_" +str(currentTime) + ".log"
         main.ReportFileName = main.logdir + "/" + main.TEST + "_" + str(currentTime) + ".rpt"
-        main.JenkinsCSV = main.logdir + "/" + main.TEST + ".csv"               
+        main.JenkinsCSV = main.logdir + "/" + main.TEST + ".csv"
  
         #### Add log-level - Report
         logging.addLevelName(9, "REPORT")
@@ -229,14 +229,14 @@
         #main.log.report(testResult)
         main.testResult = testResult
         main.log.exact(testResult)
-        
+
         ##CSV output needed for Jenkin's plot plugin
         #NOTE: the elements were orded based on the colors assigned to the data
         logfile = open(main.JenkinsCSV ,"w")
         logfile.write(",".join( ['Tests Failed', 'Tests Passed', 'Tests Planned'] ) + "\n")
-        logfile.write(",".join( [str(main.TOTAL_TC_FAIL), str(main.TOTAL_TC_PASS), str(main.TOTAL_TC_PLANNED)] ))
-        logfile.close()        
-        
+        logfile.write(",".join( [str(int(main.TOTAL_TC_FAIL)), str(int(main.TOTAL_TC_PASS)), str(int(main.TOTAL_TC_PLANNED))] ))
+        logfile.close()
+
 
 
 
diff --git a/TestON/dependencies/rotate.sh b/TestON/dependencies/rotate.sh
index 235d138..0f879b6 100755
--- a/TestON/dependencies/rotate.sh
+++ b/TestON/dependencies/rotate.sh
@@ -51,4 +51,4 @@
 #Maybe this should be an argument? pack-and-rotate supports that
 nr_max=20
 
-pack-rotate-log ${root_dir}'/'${base_name} "${root_dir}/${base_name}*.pcap" ${nr_max}
+pack-rotate-log ${root_dir}'/'${base_name} "${root_dir}/${base_name}*.pcap ${root_dir}/${base_name}*.log" ${nr_max}
diff --git a/TestON/drivers/common/api/find_node2.py b/TestON/drivers/common/api/find_node2.py
deleted file mode 100755
index eeb1504..0000000
--- a/TestON/drivers/common/api/find_node2.py
+++ /dev/null
@@ -1,44 +0,0 @@
-#! /usr/bin/env python
-import json
-import os
-import sys
-
-
-
-def find_host(RestIP,RestPort,RestAPI,hostMAC):
-    retcode = 0
-    url ="http://%s:%s/wm/device/" %(RestIP,RestPort)
-        
-    try:
-        command = "curl -s %s" % (url)
-        result = os.popen(command).read()
-        parsedResult = json.loads(result)
-    except:
-        print "REST IF %s has issue" % command
-        parsedResult = ""  
-
-    if type(parsedResult) == 'dict' and parsedResult.has_key('code'):
-        print "REST %s returned code %s" % (command, parsedResult['code'])
-        parsedResult = ""
-
-
-
-    if parsedResult == "":
-        return (retcode, "Rest API has an error")
-    else:
-        found = [item for item in parsedResult if item['mac'] == [str(hostMAC)]]
-        retcode = 1
-        return (retcode, found)
-
-
-if __name__ == "__main__":
-	ip = "10.128.100.1"
-	port = 8080
-	hostMAC = "00:00:00:00:00:06"
-	RestAPI = "/wm/device/"
-	Reststat,Hoststat = find_host(ip,port,RestAPI,hostMAC)
-	
-	if Reststat == 1:
-		print "Found device with MAC:" + hostMAC +" attached to switch(DPID):" + str(Hoststat[0]['attachmentPoint'][0]['switchDPID'])
-	else:
-		print " Device with MAC:" + hostMAC + " is not found!"
diff --git a/TestON/drivers/common/cli/check_status.py b/TestON/drivers/common/cli/check_status.py
deleted file mode 100755
index 791f1dd..0000000
--- a/TestON/drivers/common/cli/check_status.py
+++ /dev/null
@@ -1,111 +0,0 @@
-#! /usr/bin/env python
-import json
-import os
-import sys
-
-# http://localhost:8080/wm/onos/topology/switches
-# http://localhost:8080/wm/onos/topology/links
-# http://localhost:8080/wm/onos/registry/controllers/json
-# http://localhost:8080/wm/onos/registry/switches/json"
-
-def get_json(url):
-  try:
-    command = "curl -s %s" % (url)
-    result = os.popen(command).read()
-    parsedResult = json.loads(result)
-  except:
-    print "REST IF %s has issue" % command
-    parsedResult = ""
-
-  if type(parsedResult) == 'dict' and parsedResult.has_key('code'):
-    print "REST %s returned code %s" % (command, parsedResult['code'])
-    parsedResult = ""
-
-  return parsedResult 
-
-def check_switch(RestIP,correct_nr_switch ):
-  buf = ""
-  retcode = 0
-  RestPort="8080"
-
-  url="http://%s:%s/wm/onos/topology/switches" % (RestIP, RestPort)
-  parsedResult = get_json(url)
-
-  if parsedResult == "":
-    retcode = 1
-    return (retcode, "Rest API has an issue")
-
-  url = "http://%s:%s/wm/onos/registry/switches/json" % (RestIP, RestPort)
-  registry = get_json(url)
-
-  if registry == "":
-    retcode = 1
-    return (retcode, "Rest API has an issue")
-
-
-  buf += "switch: total %d switches\n" % len(parsedResult)
-  cnt = 0
-  active = 0
-
-  for s in parsedResult:
-    cnt += 1
-
-    if s['state']  == "ACTIVE":
-      active += 1
-
-    if not s['dpid'] in registry:
-      buf += "switch:  dpid %s lost controller\n" % (s['dpid'])
-
-  buf += "switch: network %d : %d switches %d active\n" % (0+1, cnt, active)
-  if correct_nr_switch != cnt:
-    buf += "switch fail: network %d should have %d switches but has %d\n" % (1, correct_nr_switch, cnt)
-    retcode = 1
-
-  if correct_nr_switch != active:
-    buf += "switch fail: network %d should have %d active switches but has %d\n" % (1, correct_nr_switch, active)
-    retcode = 1
-
-  return (retcode, buf)
-
-def check_link(RestIP, nr_links):
-  RestPort = "8080"
-  buf = ""
-  retcode = 0
-
-  url = "http://%s:%s/wm/onos/topology/links" % (RestIP, RestPort)
-  parsedResult = get_json(url)
-
-  if parsedResult == "":
-    retcode = 1
-    return (retcode, "Rest API has an issue")
-
-  buf += "link: total %d links (correct : %d)\n" % (len(parsedResult), nr_links)
-  intra = 0
-  interlink=0
-
-  for s in parsedResult:
-    intra = intra + 1 
-
-  if intra != nr_links:
-    buf += "link fail: network %d should have %d intra links but has %d\n" % (1, nr_links, intra)
-    retcode = 1
-
-  return (retcode, buf)
-
-#if __name__ == "__main__":
-def check_status(ip, numoswitch, numolink):
-
-  switch = check_switch(ip, numoswitch)
-  link = check_link(ip, numolink)
-  value = switch[0]
-  value += link[0]
-  if value != 0:
-    print "FAIL"
-    return 0
-  else: 
-    print "PASS"
-    return 1
-  print "%s" % switch[1]
-  print "%s" % link[1]
- # print "%s" % check_switch_local()[1]
- # print "%s" % check_controllers(8)[1]
diff --git a/TestON/drivers/common/cli/emulator/lincoedriver.py b/TestON/drivers/common/cli/emulator/lincoedriver.py
index 8da1700..2cb7c98 100644
--- a/TestON/drivers/common/cli/emulator/lincoedriver.py
+++ b/TestON/drivers/common/cli/emulator/lincoedriver.py
@@ -161,7 +161,7 @@
         be created. They must be brought up manually
         '''
         try:
-            self.handle.sendline("ifconfig "+str(intf)+" up")
+            self.handle.sendline("ifconfig "+str(intfs)+" up")
             self.handle.expect("linc@")
    
             handle = self.handle.before
diff --git a/TestON/drivers/common/cli/emulator/mininetclidriver.py b/TestON/drivers/common/cli/emulator/mininetclidriver.py
index 39c17c5..d883656 100644
--- a/TestON/drivers/common/cli/emulator/mininetclidriver.py
+++ b/TestON/drivers/common/cli/emulator/mininetclidriver.py
@@ -1,771 +1,896 @@
 #!/usr/bin/env python
-'''
+"""
 Created on 26-Oct-2012
 
-@author: Anil Kumar (anilkumar.s@paxterrasolutions.com)
+author:: Anil Kumar ( anilkumar.s@paxterrasolutions.com )
 
 
-    TestON is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 2 of the License, or
-    (at your option) any later version.
+TestON is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+( at your option ) any later version.
 
-    TestON is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
+TestON is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
 
-    You should have received a copy of the GNU General Public License
-    along with TestON.  If not, see <http://www.gnu.org/licenses/>.		
+You should have received a copy of the GNU General Public License
+along with TestON.  If not, see <http://www.gnu.org/licenses/>.
 
 
-MininetCliDriver is the basic driver which will handle the Mininet functions
-'''
+MininetCliDriver is the basic driver which will handle the Mininet functions"""
 import traceback
 import pexpect
-import struct
-import fcntl
-import os
-import signal
 import re
 import sys
-import core.teston
-sys.path.append("../")
+sys.path.append( "../" )
 from math import pow
 from drivers.common.cli.emulatordriver import Emulator
-from drivers.common.clidriver import CLI
 
-class MininetCliDriver(Emulator):
-    '''
-    MininetCliDriver is the basic driver which will handle the Mininet functions
-    '''
-    def __init__(self):
-        super(Emulator, self).__init__()
+
+class MininetCliDriver( Emulator ):
+
+    """
+       MininetCliDriver is the basic driver which will handle
+       the Mininet functions"""
+    def __init__( self ):
+        super( Emulator, self ).__init__()
         self.handle = self
-        self.wrapped = sys.modules[__name__]
+        self.wrapped = sys.modules[ __name__ ]
         self.flag = 0
 
-    def connect(self, **connectargs):
-        '''
-        Here the main is the TestON instance after creating all the log handles.
-        '''
+    def connect( self, **connectargs ):
+        """
+           Here the main is the TestON instance after creating
+           all the log handles."""
         for key in connectargs:
-            vars(self)[key] = connectargs[key]       
-        
-        self.name = self.options['name']
-        self.handle = super(MininetCliDriver, self).connect(user_name = self.user_name, ip_address = self.ip_address,port = None, pwd = self.pwd)
-        
+            vars( self )[ key ] = connectargs[ key ]
+
+        self.name = self.options[ 'name' ]
+        self.handle = super(
+            MininetCliDriver,
+            self ).connect(
+            user_name=self.user_name,
+            ip_address=self.ip_address,
+            port=None,
+            pwd=self.pwd )
+
         self.ssh_handle = self.handle
-        
-        if self.handle :
-            main.log.info(self.name+": Clearing any residual state or processes")
-            self.handle.sendline("sudo mn -c")
-            i=self.handle.expect(['password\sfor\s','Cleanup\scomplete',pexpect.EOF,pexpect.TIMEOUT],120)
-            if i==0:
-                main.log.info(self.name+": Sending sudo password")
-                self.handle.sendline(self.pwd)
-                i=self.handle.expect(['%s:'%(self.user),'\$',pexpect.EOF,pexpect.TIMEOUT],120) 
-            if i==1:
-                main.log.info(self.name+": Clean")
-            elif i==2:
-                main.log.error(self.name+": Connection terminated")
-            elif i==3: #timeout
-                main.log.error(self.name+": Something while cleaning MN took too long... " )
- 
-            main.log.info(self.name+": building fresh mininet") 
-            #### for reactive/PARP enabled tests
-            cmdString = "sudo mn " + self.options['arg1'] + " " + self.options['arg2'] +  " --mac --controller " + self.options['controller'] + " " + self.options['arg3']
-            
-            argList = self.options['arg1'].split(",")
+
+        if self.handle:
+            main.log.info(
+                self.name +
+                ": Clearing any residual state or processes" )
+            self.handle.sendline( "sudo mn -c" )
+            i = self.handle.expect( [ 'password\sfor\s',
+                                      'Cleanup\scomplete',
+                                      pexpect.EOF,
+                                      pexpect.TIMEOUT ],
+                                    120 )
+            if i == 0:
+                main.log.info( self.name + ": Sending sudo password" )
+                self.handle.sendline( self.pwd )
+                i = self.handle.expect( [ '%s:' % ( self.user ),
+                                          '\$',
+                                          pexpect.EOF,
+                                          pexpect.TIMEOUT ],
+                                        120 )
+            if i == 1:
+                main.log.info( self.name + ": Clean" )
+            elif i == 2:
+                main.log.error( self.name + ": Connection terminated" )
+            elif i == 3:  # timeout
+                main.log.error(
+                    self.name +
+                    ": Something while cleaning MN took too long... " )
+
+            main.log.info( self.name + ": building fresh mininet" )
+            # for reactive/PARP enabled tests
+            cmdString = "sudo mn " + self.options[ 'arg1' ] +\
+                    " " + self.options[ 'arg2' ] +\
+                    " --mac --controller " +\
+                    self.options[ 'controller' ] + " " +\
+                    self.options[ 'arg3' ]
+
+            argList = self.options[ 'arg1' ].split( "," )
             global topoArgList
-            topoArgList = argList[0].split(" ")
-            argList = map(int, argList[1:])
-            topoArgList = topoArgList[1:] + argList
-            
-          #### for proactive flow with static ARP entries
-            #cmdString = "sudo mn " + self.options['arg1'] + " " + self.options['arg2'] +  " --mac --arp --controller " + self.options['controller'] + " " + self.options['arg3']
-            self.handle.sendline(cmdString)
-            self.handle.expect(["sudo mn",pexpect.EOF,pexpect.TIMEOUT])
-            while 1: 
-                i=self.handle.expect(['mininet>','\*\*\*','Exception',pexpect.EOF,pexpect.TIMEOUT],300)
-                if i==0:
-                    main.log.info(self.name+": mininet built") 
+            topoArgList = argList[ 0 ].split( " " )
+            argList = map( int, argList[ 1: ] )
+            topoArgList = topoArgList[ 1: ] + argList
+
+            self.handle.sendline( cmdString )
+            self.handle.expect( [ "sudo mn", pexpect.EOF, pexpect.TIMEOUT ] )
+            while True:
+                i = self.handle.expect( [ 'mininet>',
+                                          '\*\*\*',
+                                          'Exception',
+                                          pexpect.EOF,
+                                          pexpect.TIMEOUT ],
+                                        300 )
+                if i == 0:
+                    main.log.info( self.name + ": mininet built" )
                     return main.TRUE
-                if i==1:
-                    self.handle.expect(["\n",pexpect.EOF,pexpect.TIMEOUT])
-                    main.log.info(self.handle.before)
-                elif i==2:
-                    main.log.error(self.name+": Launching mininet failed...")
+                if i == 1:
+                    self.handle.expect(
+                        [ "\n", pexpect.EOF, pexpect.TIMEOUT ] )
+                    main.log.info( self.handle.before )
+                elif i == 2:
+                    main.log.error(
+                        self.name +
+                        ": Launching mininet failed..." )
                     return main.FALSE
-                elif i==3:
-                    main.log.error(self.name+": Connection timeout")
+                elif i == 3:
+                    main.log.error( self.name + ": Connection timeout" )
                     return main.FALSE
-                elif i==4: #timeout
-                    main.log.error(self.name+": Something took too long... " )
+                elif i == 4:  # timeout
+                    main.log.error(
+                        self.name +
+                        ": Something took too long... " )
                     return main.FALSE
-            #if utilities.assert_matches(expect=patterns,actual=resultCommand,onpass="Network is being launched",onfail="Network launching is being failed "):
             return main.TRUE
-        else:#if no handle
-            main.log.error(self.name+": Connection failed to the host "+self.user_name+"@"+self.ip_address) 
-            main.log.error(self.name+": Failed to connect to the Mininet")
+        else:  # if no handle
+            main.log.error(
+                self.name +
+                ": Connection failed to the host " +
+                self.user_name +
+                "@" +
+                self.ip_address )
+            main.log.error( self.name + ": Failed to connect to the Mininet" )
             return main.FALSE
-                    
-    def num_switches_n_links(self,topoType,depth,fanout):
+
+    def num_switches_n_links( self, topoType, depth, fanout ):
         if topoType == 'tree':
-            if fanout is None:     #In tree topology, if fanout arg is not given, by default it is 2
+            # In tree topology, if fanout arg is not given, by default it is 2
+            if fanout is None:
                 fanout = 2
             k = 0
             count = 0
-            while(k <= depth-1): 
-                count = count + pow(fanout,k)
-                k = k+1
+            while( k <= depth - 1 ):
+                count = count + pow( fanout, k )
+                k = k + 1
                 num_switches = count
-            while(k <= depth-2): 
-                '''depth-2 gives you only core links and not considering edge links as seen by ONOS
-                    If all the links including edge links are required, do depth-1
-                '''
-                count = count + pow(fanout,k)
-                k = k+1
+            while( k <= depth - 2 ):
+                # depth-2 gives you only core links and not considering
+                # edge links as seen by ONOS. If all the links including
+                # edge links are required, do depth-1
+                count = count + pow( fanout, k )
+                k = k + 1
             num_links = count * fanout
-            #print "num_switches for %s(%d,%d) = %d and links=%d" %(topoType,depth,fanout,num_switches,num_links)
-        
-        elif topoType =='linear':
-            if fanout is None:     #In linear topology, if fanout or num_hosts_per_sw is not given, by default it is 1
+            # print "num_switches for %s(%d,%d) = %d and links=%d" %(
+            # topoType,depth,fanout,num_switches,num_links )
+
+        elif topoType == 'linear':
+            # In linear topology, if fanout or num_hosts_per_sw is not given,
+            # by default it is 1
+            if fanout is None:
                 fanout = 1
             num_switches = depth
             num_hosts_per_sw = fanout
             total_num_hosts = num_switches * num_hosts_per_sw
-            num_links = total_num_hosts + (num_switches - 1)
-            print "num_switches for %s(%d,%d) = %d and links=%d" %(topoType,depth,fanout,num_switches,num_links) 
+            num_links = total_num_hosts + ( num_switches - 1 )
+            print "num_switches for %s(%d,%d) = %d and links=%d" %\
+                    ( topoType, depth, fanout, num_switches, num_links )
         topoDict = {}
-        topoDict = {"num_switches":int(num_switches), "num_corelinks":int(num_links)}
+        topoDict = {
+            "num_switches": int( num_switches ),
+            "num_corelinks": int( num_links ) }
         return topoDict
 
-
-    def calculate_sw_and_links(self):
-        topoDict = self.num_switches_n_links(*topoArgList)
+    def calculate_sw_and_links( self ):
+        topoDict = self.num_switches_n_links( *topoArgList )
         return topoDict
 
-    def pingall(self, timeout=300):
-        '''
-        Verifies the reachability of the hosts using pingall command.
-        Optional parameter timeout allows you to specify how long to wait for pingall to complete
-        Returns:
-                main.TRUE if pingall completes with no pings dropped
-                otherwise main.FALSE
-        '''
-        if self.handle :
-            main.log.info(self.name+": Checking reachabilty to the hosts using pingall")
+    def pingall( self, timeout=300 ):
+        """
+           Verifies the reachability of the hosts using pingall command.
+           Optional parameter timeout allows you to specify how long to
+           wait for pingall to complete
+           Returns:
+           main.TRUE if pingall completes with no pings dropped
+           otherwise main.FALSE"""
+        if self.handle:
+            main.log.info(
+                self.name +
+                ": Checking reachabilty to the hosts using pingall" )
             try:
-                response = self.execute(cmd="pingall",prompt="mininet>",timeout=int(timeout))
+                response = self.execute(
+                    cmd="pingall",
+                    prompt="mininet>",
+                    timeout=int( timeout ) )
             except pexpect.EOF:
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 main.cleanup()
                 main.exit()
             except pexpect.TIMEOUT:
-                #We may not want to kill the test if pexpect times out
-                main.log.error(self.name + ": TIMEOUT exception found")
-                main.log.error(self.name + ":     " + str(self.handle.before) )
-            #NOTE: mininet's pingall rounds, so we will check the number of passed and number of failed
-            pattern = "Results\:\s0\%\sdropped\s\((?P<passed>[\d]+)/(?P=passed)"
-            if re.search(pattern,response):
-                main.log.info(self.name+": All hosts are reachable")
+                # We may not want to kill the test if pexpect times out
+                main.log.error( self.name + ": TIMEOUT exception found" )
+                main.log.error( self.name +
+                                ":     " +
+                                str( self.handle.before ) )
+            # NOTE: mininet's pingall rounds, so we will check the number of
+            # passed and number of failed
+            pattern = "Results\:\s0\%\sdropped\s\(" +\
+                    "(?P<passed>[\d]+)/(?P=passed)"
+            if re.search( pattern, response ):
+                main.log.info( self.name + ": All hosts are reachable" )
                 return main.TRUE
             else:
-                main.log.error(self.name+": Unable to reach all the hosts")
-                main.log.info("Pingall ouput: " + str(response))
-                #NOTE: Send ctrl-c to make sure pingall is done
-                #self.handle.send("\x03")
-                self.handle.sendcontrol('c')
-                #self.handle.expect("Interrupt")
-                self.handle.expect("mininet>")
+               main.log.error( self.name + ": Unable to reach all the hosts" )
+                main.log.info( "Pingall ouput: " + str( response ) )
+                # NOTE: Send ctrl-c to make sure pingall is done
+                self.handle.send( "\x03" )
+                self.handle.expect( "Interrupt" )
+                self.handle.expect( "mininet>" )
                 return main.FALSE
-        else :
-            main.log.error(self.name+": Connection failed to the host") 
+        else:
+            main.log.error( self.name + ": Connection failed to the host" )
             main.cleanup()
             main.exit()
 
-    def fpingHost(self,**pingParams):
-        ''' 
-        Uses the fping package for faster pinging...
-        *requires fping to be installed on machine running mininet 
-        ''' 
-        args = utilities.parse_args(["SRC","TARGET"],**pingParams)
-        command = args["SRC"] + " fping -i 100 -t 20 -C 1 -q "+args["TARGET"]
-        self.handle.sendline(command) 
-        self.handle.expect([args["TARGET"],pexpect.EOF,pexpect.TIMEOUT]) 
-        self.handle.expect(["mininet",pexpect.EOF,pexpect.TIMEOUT])
-        response = self.handle.before 
-        if re.search(":\s-" ,response):
-            main.log.info(self.name+": Ping fail") 
+    def fpingHost( self, **pingParams ):
+        """
+           Uses the fping package for faster pinging...
+           *requires fping to be installed on machine running mininet"""
+        args = utilities.parse_args( [ "SRC", "TARGET" ], **pingParams )
+        command = args[ "SRC" ] + \
+            " fping -i 100 -t 20 -C 1 -q " + args[ "TARGET" ]
+        self.handle.sendline( command )
+        self.handle.expect(
+            [ args[ "TARGET" ], pexpect.EOF, pexpect.TIMEOUT ] )
+        self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
+        response = self.handle.before
+        if re.search( ":\s-", response ):
+            main.log.info( self.name + ": Ping fail" )
             return main.FALSE
-        elif re.search(":\s\d{1,2}\.\d\d", response):
-            main.log.info(self.name+": Ping good!")
+        elif re.search( ":\s\d{1,2}\.\d\d", response ):
+            main.log.info( self.name + ": Ping good!" )
             return main.TRUE
-        main.log.info(self.name+": Install fping on mininet machine... ") 
-        main.log.info(self.name+": \n---\n"+response)
+        main.log.info( self.name + ": Install fping on mininet machine... " )
+        main.log.info( self.name + ": \n---\n" + response )
         return main.FALSE
-        
-    def pingHost(self,**pingParams):
-        '''
-        Ping from one mininet host to another
-        Currently the only supported Params: SRC and TARGET
-        '''
-        args = utilities.parse_args(["SRC","TARGET"],**pingParams)
-        #command = args["SRC"] + " ping -" + args["CONTROLLER"] + " " +args ["TARGET"]
-        command = args["SRC"] + " ping "+args ["TARGET"]+" -c 1 -i 1 -W 8"
+
+    def pingHost( self, **pingParams ):
+        """
+           Ping from one mininet host to another
+           Currently the only supported Params: SRC and TARGET"""
+        args = utilities.parse_args( [ "SRC", "TARGET" ], **pingParams )
+        command = args[ "SRC" ] + " ping " + \
+            args[ "TARGET" ] + " -c 1 -i 1 -W 8"
         try:
-            main.log.warn("Sending: " + command)
-            #response = self.execute(cmd=command,prompt="mininet",timeout=10 )
-            self.handle.sendline(command)
-            i = self.handle.expect([command,pexpect.TIMEOUT])
+            main.log.warn( "Sending: " + command )
+            self.handle.sendline( command )
+            i = self.handle.expect( [ command, pexpect.TIMEOUT ] )
             if i == 1:
-                main.log.error(self.name + ": timeout when waiting for response from mininet")
-                main.log.error("response: " + str(self.handle.before))
-            i = self.handle.expect(["mininet>",pexpect.TIMEOUT])
+                main.log.error(
+                    self.name +
+                    ": timeout when waiting for response from mininet" )
+                main.log.error( "response: " + str( self.handle.before ) )
+            i = self.handle.expect( [ "mininet>", pexpect.TIMEOUT ] )
             if i == 1:
-                main.log.error(self.name + ": timeout when waiting for response from mininet")
-                main.log.error("response: " + str(self.handle.before))
+                main.log.error(
+                    self.name +
+                    ": timeout when waiting for response from mininet" )
+                main.log.error( "response: " + str( self.handle.before ) )
             response = self.handle.before
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
-        main.log.info(self.name+": Ping Response: "+ response )
-        #if utilities.assert_matches(expect=',\s0\%\spacket\sloss',actual=response,onpass="No Packet loss",onfail="Host is not reachable"):
-        if re.search(',\s0\%\spacket\sloss',response):
-            main.log.info(self.name+": no packets lost, host is reachable")
-            main.last_result = main.TRUE 
+        main.log.info( self.name + ": Ping Response: " + response )
+        if re.search( ',\s0\%\spacket\sloss', response ):
+            main.log.info( self.name + ": no packets lost, host is reachable" )
+            main.last_result = main.TRUE
             return main.TRUE
-        else :
-            main.log.error(self.name+": PACKET LOST, HOST IS NOT REACHABLE")
+        else:
+            main.log.error(
+                self.name +
+                ": PACKET LOST, HOST IS NOT REACHABLE" )
             main.last_result = main.FALSE
             return main.FALSE
-    
-    def checkIP(self,host):
-        '''
-        Verifies the host's ip configured or not.
-        '''
-        if self.handle :
+
+    def checkIP( self, host ):
+        """
+           Verifies the host's ip configured or not."""
+        if self.handle:
             try:
-                response = self.execute(cmd=host+" ifconfig",prompt="mininet>",timeout=10)
-            except pexpect.EOF:  
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                response = self.execute(
+                    cmd=host +
+                    " ifconfig",
+                    prompt="mininet>",
+                    timeout=10 )
+            except pexpect.EOF:
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 main.cleanup()
                 main.exit()
 
-            pattern = "inet\s(addr|Mask):([0-1]{1}[0-9]{1,2}|2[0-4][0-9]|25[0-5]|[0-9]{1,2}).([0-1]{1}[0-9]{1,2}|2[0-4][0-9]|25[0-5]|[0-9]{1,2}).([0-1]{1}[0-9]{1,2}|2[0-4][0-9]|25[0-5]|[0-9]{1,2}).([0-1]{1}[0-9]{1,2}|2[0-4][0-9]|25[0-5]|[0-9]{1,2})"
-            #pattern = "inet addr:10.0.0.6"  
-            #if utilities.assert_matches(expect=pattern,actual=response,onpass="Host Ip configured properly",onfail="Host IP not found") :
-            if re.search(pattern,response):
-                main.log.info(self.name+": Host Ip configured properly")
+            pattern = "inet\s(addr|Mask):([0-1]{1}[0-9]{1,2}|" +\
+                    "2[0-4][0-9]|25[0-5]|[0-9]{1,2}).([0-1]{1}" +\
+                    "[0-9]{1,2}|2[0-4][0-9]|25[0-5]|[0-9]{1,2})." +\
+                    "([0-1]{1}[0-9]{1,2}|2[0-4][0-9]|25[0-5]|" +\
+                    "[0-9]{1,2}).([0-1]{1}[0-9]{1,2}|2[0-4]" +\
+                    "[0-9]|25[0-5]|[0-9]{1,2})"
+            # pattern = "inet addr:10.0.0.6"
+            if re.search( pattern, response ):
+                main.log.info( self.name + ": Host Ip configured properly" )
                 return main.TRUE
             else:
-                main.log.error(self.name+": Host IP not found")
+                main.log.error( self.name + ": Host IP not found" )
                 return main.FALSE
-        else :
-            main.log.error(self.name+": Connection failed to the host") 
-            
-    def verifySSH(self,**connectargs):
+        else:
+            main.log.error( self.name + ": Connection failed to the host" )
+
+    def verifySSH( self, **connectargs ):
         try:
-            response = self.execute(cmd="h1 /usr/sbin/sshd -D&",prompt="mininet>",timeout=10)
-            response = self.execute(cmd="h4 /usr/sbin/sshd -D&",prompt="mininet>",timeout=10)
+            response = self.execute(
+                cmd="h1 /usr/sbin/sshd -D&",
+                prompt="mininet>",
+                timeout=10 )
+            response = self.execute(
+                cmd="h4 /usr/sbin/sshd -D&",
+                prompt="mininet>",
+                timeout=10 )
             for key in connectargs:
-                vars(self)[key] = connectargs[key]
-            response = self.execute(cmd="xterm h1 h4 ",prompt="mininet>",timeout=10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+                vars( self )[ key ] = connectargs[ key ]
+            response = self.execute(
+                cmd="xterm h1 h4 ",
+                prompt="mininet>",
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         import time
-        time.sleep(20)
+        time.sleep( 20 )
         if self.flag == 0:
             self.flag = 1
             return main.FALSE
-        else :
+        else:
             return main.TRUE
 
-    
-
-
-    def changeIP(self,host,intf,newIP,newNetmask):
-        '''
-        Changes the ip address of a host on the fly
-        Ex: h2 ifconfig h2-eth0 10.0.1.2 netmask 255.255.255.0
-        '''
+    def changeIP( self, host, intf, newIP, newNetmask ):
+        """
+           Changes the ip address of a host on the fly
+           Ex: h2 ifconfig h2-eth0 10.0.1.2 netmask 255.255.255.0"""
         if self.handle:
             try:
-                cmd = host+" ifconfig "+intf+" "+newIP+" "+'netmask'+" "+newNetmask
-                self.handle.sendline(cmd)
-                self.handle.expect("mininet>")
+                cmd = host + " ifconfig " + intf + " " + \
+                    newIP + " " + 'netmask' + " " + newNetmask
+                self.handle.sendline( cmd )
+                self.handle.expect( "mininet>" )
                 response = self.handle.before
-                main.log.info("response = "+response)
-                main.log.info("Ip of host "+host+" changed to new IP "+newIP)
+                main.log.info( "response = " + response )
+                main.log.info(
+                    "Ip of host " +
+                    host +
+                    " changed to new IP " +
+                    newIP )
                 return main.TRUE
             except pexpect.EOF:
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 return main.FALSE
 
-    def changeDefaultGateway(self,host,newGW):
-        '''
-        Changes the default gateway of a host
-        Ex: h1 route add default gw 10.0.1.2
-        '''
+    def changeDefaultGateway( self, host, newGW ):
+        """
+           Changes the default gateway of a host
+           Ex: h1 route add default gw 10.0.1.2"""
         if self.handle:
             try:
-                cmd = host+" route add default gw "+newGW 
-                self.handle.sendline(cmd)
-                self.handle.expect("mininet>")
+                cmd = host + " route add default gw " + newGW
+                self.handle.sendline( cmd )
+                self.handle.expect( "mininet>" )
                 response = self.handle.before
-                main.log.info("response = "+response)
-                main.log.info("Default gateway of host "+host+" changed to "+newGW)
+                main.log.info( "response = " + response )
+                main.log.info(
+                    "Default gateway of host " +
+                    host +
+                    " changed to " +
+                    newGW )
                 return main.TRUE
             except pexpect.EOF:
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 return main.FALSE
-  
-    def addStaticMACAddress(self,host,GW,macaddr):
-        '''
-        Changes the mac address of a geateway host
-        '''
+
+    def addStaticMACAddress( self, host, GW, macaddr ):
+        """
+           Changes the mac address of a geateway host"""
         if self.handle:
             try:
-                #h1  arp -s 10.0.1.254 00:00:00:00:11:11 
-                cmd = host+" arp -s "+GW+" "+macaddr
-                self.handle.sendline(cmd)
-                self.handle.expect("mininet>")
+                # h1  arp -s 10.0.1.254 00:00:00:00:11:11
+                cmd = host + " arp -s " + GW + " " + macaddr
+                self.handle.sendline( cmd )
+                self.handle.expect( "mininet>" )
                 response = self.handle.before
-                main.log.info("response = "+response)
-                main.log.info("Mac adrress of gateway "+GW+" changed to "+macaddr)
+                main.log.info( "response = " + response )
+                main.log.info(
+                    "Mac adrress of gateway " +
+                    GW +
+                    " changed to " +
+                    macaddr )
                 return main.TRUE
             except pexpect.EOF:
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 return main.FALSE
 
-    def verifyStaticGWandMAC(self,host):
-        '''
-        Verify if the static gateway and mac address assignment 
-        '''
+    def verifyStaticGWandMAC( self, host ):
+        """
+           Verify if the static gateway and mac address assignment"""
         if self.handle:
             try:
-                #h1  arp -an
-                cmd = host+" arp -an "
-                self.handle.sendline(cmd)
-                self.handle.expect("mininet>")
+                # h1  arp -an
+                cmd = host + " arp -an "
+                self.handle.sendline( cmd )
+                self.handle.expect( "mininet>" )
                 response = self.handle.before
-                main.log.info(host+" arp -an = "+response)
+                main.log.info( host + " arp -an = " + response )
                 return main.TRUE
             except pexpect.EOF:
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 return main.FALSE
 
-
-
-    def getMacAddress(self,host):
-        '''
-        Verifies the host's ip configured or not.
-        '''
-        if self.handle :
+    def getMacAddress( self, host ):
+        """
+           Verifies the host's ip configured or not."""
+        if self.handle:
             try:
-                response = self.execute(cmd=host+" ifconfig",prompt="mininet>",timeout=10)
-            except pexpect.EOF:  
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                response = self.execute(
+                    cmd=host +
+                    " ifconfig",
+                    prompt="mininet>",
+                    timeout=10 )
+            except pexpect.EOF:
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 main.cleanup()
                 main.exit()
 
             pattern = r'HWaddr\s([0-9A-F]{2}[:-]){5}([0-9A-F]{2})'
-            mac_address_search = re.search(pattern, response, re.I)
-            mac_address = mac_address_search.group().split(" ")[1]
-            main.log.info(self.name+": Mac-Address of Host "+ host + " is " + mac_address)
-            return mac_address
-        else :
-            main.log.error(self.name+": Connection failed to the host") 
-
-    def getInterfaceMACAddress(self,host, interface):
-        '''
-            Return the IP address of the interface on the given host
-        '''
-        if self.handle :
-            try:
-                response = self.execute(cmd=host+" ifconfig " + interface,
-                                    prompt="mininet>",timeout=10)
-            except pexpect.EOF:  
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
-                main.cleanup()
-                main.exit()
-
-            pattern = r'HWaddr\s([0-9A-F]{2}[:-]){5}([0-9A-F]{2})'
-            mac_address_search = re.search(pattern, response, re.I)
-            if mac_address_search is None:
-                main.log.info("No mac address found in %s" % response)
-                return main.FALSE
-            mac_address = mac_address_search.group().split(" ")[1]
-            main.log.info("Mac-Address of "+ host + ":"+ interface + " is " + mac_address)
+            mac_address_search = re.search( pattern, response, re.I )
+            mac_address = mac_address_search.group().split( " " )[ 1 ]
+            main.log.info(
+                self.name +
+                ": Mac-Address of Host " +
+                host +
+                " is " +
+                mac_address )
             return mac_address
         else:
-            main.log.error("Connection failed to the host")
+            main.log.error( self.name + ": Connection failed to the host" )
 
-    def getIPAddress(self,host):
-        '''
-        Verifies the host's ip configured or not.
-        '''
-        if self.handle :
+    def getInterfaceMACAddress( self, host, interface ):
+        """
+           Return the IP address of the interface on the given host"""
+        if self.handle:
             try:
-                response = self.execute(cmd=host+" ifconfig",prompt="mininet>",timeout=10)
-            except pexpect.EOF:  
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                response = self.execute( cmd=host + " ifconfig " + interface,
+                                         prompt="mininet>", timeout=10 )
+            except pexpect.EOF:
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
+                main.cleanup()
+                main.exit()
+
+            pattern = r'HWaddr\s([0-9A-F]{2}[:-]){5}([0-9A-F]{2})'
+            mac_address_search = re.search( pattern, response, re.I )
+            if mac_address_search is None:
+                main.log.info( "No mac address found in %s" % response )
+                return main.FALSE
+            mac_address = mac_address_search.group().split( " " )[ 1 ]
+            main.log.info(
+                "Mac-Address of " +
+                host +
+                ":" +
+                interface +
+                " is " +
+                mac_address )
+            return mac_address
+        else:
+            main.log.error( "Connection failed to the host" )
+
+    def getIPAddress( self, host ):
+        """
+           Verifies the host's ip configured or not."""
+        if self.handle:
+            try:
+                response = self.execute(
+                    cmd=host +
+                    " ifconfig",
+                    prompt="mininet>",
+                    timeout=10 )
+            except pexpect.EOF:
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 main.cleanup()
                 main.exit()
 
             pattern = "inet\saddr:(\d+\.\d+\.\d+\.\d+)"
-            ip_address_search = re.search(pattern, response)
-            main.log.info(self.name+": IP-Address of Host "+host +" is "+ip_address_search.group(1))
-            return ip_address_search.group(1)
-        else :
-            main.log.error(self.name+": Connection failed to the host") 
-        
-    def getSwitchDPID(self,switch):
-        '''
-            return the datapath ID of the switch
-        '''
-        if self.handle :
+            ip_address_search = re.search( pattern, response )
+            main.log.info(
+                self.name +
+                ": IP-Address of Host " +
+                host +
+                " is " +
+                ip_address_search.group( 1 ) )
+            return ip_address_search.group( 1 )
+        else:
+            main.log.error( self.name + ": Connection failed to the host" )
+
+    def getSwitchDPID( self, switch ):
+        """
+           return the datapath ID of the switch"""
+        if self.handle:
             cmd = "py %s.dpid" % switch
             try:
-                response = self.execute(cmd=cmd,prompt="mininet>",timeout=10)
-            except pexpect.EOF:  
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                response = self.execute(
+                    cmd=cmd,
+                    prompt="mininet>",
+                    timeout=10 )
+            except pexpect.EOF:
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 main.cleanup()
                 main.exit()
-            pattern = r'^(?P<dpid>\d)+'
-            result = re.search(pattern, response, re.MULTILINE)
+            pattern = r'^(?P<dpid>\w)+'
+            result = re.search( pattern, response, re.MULTILINE )
             if result is None:
-                main.log.info("Couldn't find DPID for switch '', found: %s" % (switch, response))
+                main.log.info(
+                    "Couldn't find DPID for switch %s, found: %s" %
+                    ( switch, response ) )
                 return main.FALSE
-            return str(result.group(0))
+            return str( result.group( 0 ) ).lower()
         else:
-            main.log.error("Connection failed to the host")
+            main.log.error( "Connection failed to the host" )
 
-    def getDPID(self, switch):
+    def getDPID( self, switch ):
         if self.handle:
-            self.handle.sendline("")
-            self.expect("mininet>")
-            cmd = "py %s.dpid" %switch
+            self.handle.sendline( "" )
+            self.expect( "mininet>" )
+            cmd = "py %s.dpid" % switch
             try:
-                response = self.execute(cmd=cmd,prompt="mininet>",timeout=10)
-                self.handle.expect("mininet>")
+                response = self.execute(
+                    cmd=cmd,
+                    prompt="mininet>",
+                    timeout=10 )
+                self.handle.expect( "mininet>" )
                 response = self.handle.before
                 return response
             except pexpect.EOF:
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 main.cleanup()
                 main.exit()
 
-
-    def getInterfaces(self, node):
-        '''
-            return information dict about interfaces connected to the node
-        '''
-        if self.handle :
-            cmd = 'py "\\n".join(["name=%s,mac=%s,ip=%s,enabled=%s" % (i.name, i.MAC(), i.IP(), i.isUp())'
+    def getInterfaces( self, node ):
+        """
+           return information dict about interfaces connected to the node"""
+        if self.handle:
+            cmd = 'py "\\n".join(["name=%s,mac=%s,ip=%s,enabled=%s"' +\
+                    ' % (i.name, i.MAC(), i.IP(), i.isUp())'
             cmd += ' for i in %s.intfs.values()])' % node
             try:
-                response = self.execute(cmd=cmd,prompt="mininet>",timeout=10)
-            except pexpect.EOF:  
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                response = self.execute(
+                    cmd=cmd,
+                    prompt="mininet>",
+                    timeout=10 )
+            except pexpect.EOF:
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 main.cleanup()
                 main.exit()
             return response
         else:
-            main.log.error("Connection failed to the node")
+            main.log.error( "Connection failed to the node" )
 
-    def dump(self):
-        main.log.info(self.name+": Dump node info")
+    def dump( self ):
+        main.log.info( self.name + ": Dump node info" )
         try:
-            response = self.execute(cmd = 'dump',prompt = 'mininet>',timeout = 10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            response = self.execute(
+                cmd='dump',
+                prompt='mininet>',
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         return response
-            
-    def intfs(self):
-        main.log.info(self.name+": List interfaces")
+
+    def intfs( self ):
+        main.log.info( self.name + ": List interfaces" )
         try:
-            response = self.execute(cmd = 'intfs',prompt = 'mininet>',timeout = 10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            response = self.execute(
+                cmd='intfs',
+                prompt='mininet>',
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         return response
-    
-    def net(self):
-        main.log.info(self.name+": List network connections")
+
+    def net( self ):
+        main.log.info( self.name + ": List network connections" )
         try:
-            response = self.execute(cmd = 'net',prompt = 'mininet>',timeout = 10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            response = self.execute( cmd='net', prompt='mininet>', timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         return response
-    '''
-    def iperf(self,host1,host2):
-        main.log.info(self.name+": Simple iperf TCP test between two (optionally specified) hosts")
+
+    def iperf( self, host1, host2 ):
+        main.log.info(
+            self.name +
+            ": Simple iperf TCP test between two hosts" )
         try:
-            if not host1 and not host2:
-                response = self.execute(cmd = 'iperf',prompt = 'mininet>',timeout = 10)
-            else:
-                cmd1 = 'iperf '+ host1 + " " + host2
-                response = self.execute(cmd = cmd1, prompt = '>',timeout = 20)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
-            main.cleanup()
-            main.exit()
-        return response
-     '''
-    def iperf(self,host1,host2):
-        main.log.info(self.name+": Simple iperf TCP test between two hosts")
-        try:
-            cmd1 = 'iperf '+ host1 + " " + host2
-            self.handle.sendline(cmd1)
-            self.handle.expect("mininet>") 
+            cmd1 = 'iperf ' + host1 + " " + host2
+            self.handle.sendline( cmd1 )
+            self.handle.expect( "mininet>" )
             response = self.handle.before
-            if re.search('Results:',response):
-                main.log.info(self.name+": iperf test succssful")
+            if re.search( 'Results:', response ):
+                main.log.info( self.name + ": iperf test succssful" )
                 return main.TRUE
             else:
-                main.log.error(self.name+": iperf test failed")
-                return main.FALSE 
+                main.log.error( self.name + ": iperf test failed" )
+                return main.FALSE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
-    
-    def iperfudp(self):
-        main.log.info(self.name+": Simple iperf TCP test between two (optionally specified) hosts")
+
+    def iperfudp( self ):
+        main.log.info(
+            self.name +
+            ": Simple iperf TCP test between two " +
+            "(optionally specified) hosts" )
         try:
-            response = self.execute(cmd = 'iperfudp',prompt = 'mininet>',timeout = 10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            response = self.execute(
+                cmd='iperfudp',
+                prompt='mininet>',
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         return response
-    
-    def nodes(self):
-        main.log.info(self.name+": List all nodes.")
+
+    def nodes( self ):
+        main.log.info( self.name + ": List all nodes." )
         try:
-            response = self.execute(cmd = 'nodes',prompt = 'mininet>',timeout = 10)    
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            response = self.execute(
+                cmd='nodes',
+                prompt='mininet>',
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         return response
-    
-    def pingpair(self):
-        main.log.info(self.name+": Ping between first two hosts")
+
+    def pingpair( self ):
+        main.log.info( self.name + ": Ping between first two hosts" )
         try:
-            response = self.execute(cmd = 'pingpair',prompt = 'mininet>',timeout = 20)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            response = self.execute(
+                cmd='pingpair',
+                prompt='mininet>',
+                timeout=20 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
-        
-        #if utilities.assert_matches(expect='0% packet loss',actual=response,onpass="No Packet loss",onfail="Hosts not reachable"):
-        if re.search(',\s0\%\spacket\sloss',response):
-            main.log.info(self.name+": Ping between two hosts SUCCESSFUL")
-            main.last_result = main.TRUE 
+
+        if re.search( ',\s0\%\spacket\sloss', response ):
+            main.log.info( self.name + ": Ping between two hosts SUCCESSFUL" )
+            main.last_result = main.TRUE
             return main.TRUE
-        else :
-            main.log.error(self.name+": PACKET LOST, HOSTS NOT REACHABLE")
+        else:
+            main.log.error( self.name + ": PACKET LOST, HOSTS NOT REACHABLE" )
             main.last_result = main.FALSE
             return main.FALSE
-    
-    def link(self,**linkargs):
-        '''
-        Bring link(s) between two nodes up or down
-        '''
-        args = utilities.parse_args(["END1","END2","OPTION"],**linkargs)
-        end1 = args["END1"] if args["END1"] != None else ""
-        end2 = args["END2"] if args["END2"] != None else ""
-        option = args["OPTION"] if args["OPTION"] != None else ""
-        main.log.info("Bring link between '"+ end1 +"' and '" + end2 + "' '" + option + "'")
-        command = "link "+str(end1) + " " + str(end2)+ " " + str(option)
-        try:
-            #response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-            self.handle.sendline(command)
-            self.handle.expect("mininet>")    
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
-            main.cleanup()
-            main.exit()
-        return main.TRUE
-        
 
-    def yank(self,**yankargs):
-	'''
-	yank a mininet switch interface to a host
-	'''
-	main.log.info('Yank the switch interface attached to a host')
-	args = utilities.parse_args(["SW","INTF"],**yankargs)
-	sw = args["SW"] if args["SW"] !=None else ""
-	intf = args["INTF"] if args["INTF"] != None else ""
-	command = "py "+ str(sw) + '.detach("' + str(intf) + '")'
+    def link( self, **linkargs ):
+        """
+           Bring link( s ) between two nodes up or down"""
+        args = utilities.parse_args( [ "END1", "END2", "OPTION" ], **linkargs )
+        end1 = args[ "END1" ] if args[ "END1" ] is not None else ""
+        end2 = args[ "END2" ] if args[ "END2" ] is not None else ""
+        option = args[ "OPTION" ] if args[ "OPTION" ] is not None else ""
+        main.log.info(
+            "Bring link between '" +
+            end1 +
+            "' and '" +
+            end2 +
+            "' '" +
+            option +
+            "'" )
+        command = "link " + \
+            str( end1 ) + " " + str( end2 ) + " " + str( option )
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
-            main.cleanup()
-            main.exit()
-	return main.TRUE
-
-    def plug(self, **plugargs):
-        '''
-        plug the yanked mininet switch interface to a switch
-        '''
-        main.log.info('Plug the switch interface attached to a switch')
-        args = utilities.parse_args(["SW","INTF"],**plugargs)
-        sw = args["SW"] if args["SW"] !=None else ""
-        intf = args["INTF"] if args["INTF"] != None else ""
-        command = "py "+ str(sw) + '.attach("' + str(intf) + '")'
-        try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            self.handle.sendline( command )
+            self.handle.expect( "mininet>" )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         return main.TRUE
 
-
-
-    def dpctl(self,**dpctlargs):
-        '''
-        Run dpctl command on all switches.
-        '''
-        main.log.info('Run dpctl command on all switches')
-        args = utilities.parse_args(["CMD","ARGS"],**dpctlargs)
-        cmd = args["CMD"] if args["CMD"] != None else ""
-        cmdargs = args["ARGS"] if args["ARGS"] != None else ""
-        command = "dpctl "+cmd + " " + str(cmdargs)
+    def yank( self, **yankargs ):
+        """
+           yank a mininet switch interface to a host"""
+        main.log.info( 'Yank the switch interface attached to a host' )
+        args = utilities.parse_args( [ "SW", "INTF" ], **yankargs )
+        sw = args[ "SW" ] if args[ "SW" ] is not None else ""
+        intf = args[ "INTF" ] if args[ "INTF" ] is not None else ""
+        command = "py " + str( sw ) + '.detach("' + str(intf) + '")'
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         return main.TRUE
-   
-        
-    def get_version(self):
-        file_input = path+'/lib/Mininet/INSTALL'
-        version = super(Mininet, self).get_version()
+
+    def plug( self, **plugargs ):
+        """
+           plug the yanked mininet switch interface to a switch"""
+        main.log.info( 'Plug the switch interface attached to a switch' )
+        args = utilities.parse_args( [ "SW", "INTF" ], **plugargs )
+        sw = args[ "SW" ] if args[ "SW" ] is not None else ""
+        intf = args[ "INTF" ] if args[ "INTF" ] is not None else ""
+        command = "py " + str( sw ) + '.attach("' + str(intf) + '")'
+        try:
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
+            main.cleanup()
+            main.exit()
+        return main.TRUE
+
+    def dpctl( self, **dpctlargs ):
+        """
+           Run dpctl command on all switches."""
+        main.log.info( 'Run dpctl command on all switches' )
+        args = utilities.parse_args( [ "CMD", "ARGS" ], **dpctlargs )
+        cmd = args[ "CMD" ] if args[ "CMD" ] is not None else ""
+        cmdargs = args[ "ARGS" ] if args[ "ARGS" ] is not None else ""
+        command = "dpctl " + cmd + " " + str( cmdargs )
+        try:
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
+            main.cleanup()
+            main.exit()
+        return main.TRUE
+
+    def get_version( self ):
+        file_input = path + '/lib/Mininet/INSTALL'
+        version = super( Mininet, self ).get_version()
         pattern = 'Mininet\s\w\.\w\.\w\w*'
-        for line in open(file_input,'r').readlines():
-            result = re.match(pattern, line)
+        for line in open( file_input, 'r' ).readlines():
+            result = re.match( pattern, line )
             if result:
-                version = result.group(0)
+                version = result.group( 0 )
         return version
 
-    def get_sw_controller(self, sw):
-        '''
+    def get_sw_controller( self, sw ):
+        """
         Parameters:
             sw: The name of an OVS switch. Example "s1"
         Return:
-            The output of the command from the mininet cli or main.FALSE on timeout
-        '''
-        command = "sh ovs-vsctl get-controller "+str(sw)
+            The output of the command from the mininet cli
+            or main.FALSE on timeout"""
+        command = "sh ovs-vsctl get-controller " + str( sw )
         try:
-            response = self.execute(cmd=command, prompt="mininet>", timeout=10)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
             if response:
                 return response
             else:
                 return main.FALSE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
 
-    def assign_sw_controller(self,**kwargs):
-        '''
-        count is only needed if there is more than 1 controller
-        '''
-        args = utilities.parse_args(["COUNT"],**kwargs)
-        count = args["COUNT"] if args!={} else 1
+    def assign_sw_controller( self, **kwargs ):
+        """
+           count is only needed if there is more than 1 controller"""
+        args = utilities.parse_args( [ "COUNT" ], **kwargs )
+        count = args[ "COUNT" ] if args != {} else 1
 
         argstring = "SW"
-        for j in range(count):
-            argstring = argstring + ",IP" + str(j+1) + ",PORT" + str(j+1)
-        args = utilities.parse_args(argstring.split(","),**kwargs)
+        for j in range( count ):
+            argstring = argstring + ",IP" + \
+                str( j + 1 ) + ",PORT" + str( j + 1 )
+        args = utilities.parse_args( argstring.split( "," ), **kwargs )
 
-        sw = args["SW"] if args["SW"] != None else ""
-        ptcpA = int(args["PORT1"])+int(sw) if args["PORT1"] != None else ""
-        ptcpB = "ptcp:"+str(ptcpA) if ptcpA != "" else ""
-        
-        command = "sh ovs-vsctl set-controller s" + str(sw) + " " + ptcpB + " "
-        for j in range(count):
-            i=j+1
-            args = utilities.parse_args(["IP"+str(i),"PORT"+str(i)],**kwargs)
-            ip = args["IP"+str(i)] if args["IP"+str(i)] != None else ""
-            port = args["PORT" + str(i)] if args["PORT" + str(i)] != None else ""
-            tcp = "tcp:" + str(ip) + ":" + str(port) + " " if ip != "" else ""
+        sw = args[ "SW" ] if args[ "SW" ] is not None else ""
+        ptcpA = int( args[ "PORT1" ] ) + \
+                    int( sw ) if args[ "PORT1" ] is not None else ""
+        ptcpB = "ptcp:" + str( ptcpA ) if ptcpA != "" else ""
+
+        command = "sh ovs-vsctl set-controller s" + \
+            str( sw ) + " " + ptcpB + " "
+        for j in range( count ):
+            i = j + 1
+            args = utilities.parse_args(
+                [ "IP" + str( i ), "PORT" + str( i ) ], **kwargs )
+            ip = args[
+                "IP" +
+                str( i ) ] if args[
+                "IP" +
+                str( i ) ] is not None else ""
+            port = args[
+                "PORT" +
+                str( i ) ] if args[
+                "PORT" +
+                str( i ) ] is not None else ""
+            tcp = "tcp:" + str( ip ) + ":" + str( port ) + \
+                               " " if ip != "" else ""
             command = command + tcp
         try:
-            self.execute(cmd=command,prompt="mininet>",timeout=5)
+            self.execute( cmd=command, prompt="mininet>", timeout=5 )
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         except:
-            main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            main.log.info( self.name + ":" * 50 )
             main.log.error( traceback.print_exc() )
-            main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            main.log.info(":" * 50 )
             main.cleanup()
             main.exit()
 
-    def delete_sw_controller(self,sw):
-        '''
-        Removes the controller target from sw
-        '''
-
-        command = "sh ovs-vsctl del-controller "+str(sw)
+    def delete_sw_controller( self, sw ):
+        """
+           Removes the controller target from sw"""
+        command = "sh ovs-vsctl del-controller " + str( sw )
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         else:
-            main.log.info(response)
+            main.log.info( response )
 
     def add_switch( self, sw, **kwargs ):
-        '''
+        """
         adds a switch to the mininet topology
         NOTE: this uses a custom mn function
         NOTE: cannot currently specify what type of switch
@@ -774,117 +899,126 @@
         optional keyvalues:
             dpid = "dpid"
         returns: main.FASLE on an error, else main.TRUE
-        '''
-        dpid = kwargs.get('dpid', '')
+        """
+        dpid = kwargs.get( 'dpid', '' )
         command = "addswitch " + str( sw ) + " " + str( dpid )
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-            if re.search("already exists!", response):
-                main.log.warn(response)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+            if re.search( "already exists!", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("Error", response):
-                main.log.warn(response)
+            elif re.search( "Error", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("usage:", response):
-                main.log.warn(response)
+            elif re.search( "usage:", response ):
+                main.log.warn( response )
                 return main.FALSE
             else:
                 return main.TRUE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
 
     def del_switch( self, sw ):
-        '''
-        delete a switch from the mininet topology
-        NOTE: this uses a custom mn function
-        required params:
+        """
+           delete a switch from the mininet topology
+           NOTE: this uses a custom mn function
+           required params:
             switchname = name of the switch as a string
-        returns: main.FASLE on an error, else main.TRUE
-        '''
+           returns: main.FASLE on an error, else main.TRUE"""
         command = "delswitch " + str( sw )
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-            if re.search("no switch named", response):
-                main.log.warn(response)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+            if re.search( "no switch named", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("Error", response):
-                main.log.warn(response)
+            elif re.search( "Error", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("usage:", response):
-                main.log.warn(response)
+            elif re.search( "usage:", response ):
+                main.log.warn( response )
                 return main.FALSE
             else:
                 return main.TRUE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
 
     def add_link( self, node1, node2 ):
-        '''
-        add a link to the mininet topology
-        NOTE: this uses a custom mn function
-        NOTE: cannot currently specify what type of link
-        required params:
-            node1 = the string node name of the first endpoint of the link
-            node2 = the string node name of the second endpoint of the link
-        returns: main.FASLE on an error, else main.TRUE
-        '''
+        """
+           add a link to the mininet topology
+           NOTE: this uses a custom mn function
+           NOTE: cannot currently specify what type of link
+           required params:
+           node1 = the string node name of the first endpoint of the link
+           node2 = the string node name of the second endpoint of the link
+           returns: main.FASLE on an error, else main.TRUE"""
         command = "addlink " + str( node1 ) + " " + str( node2 )
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-            if re.search("doesnt exist!", response):
-                main.log.warn(response)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+            if re.search( "doesnt exist!", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("Error", response):
-                main.log.warn(response)
+            elif re.search( "Error", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("usage:", response):
-                main.log.warn(response)
+            elif re.search( "usage:", response ):
+                main.log.warn( response )
                 return main.FALSE
             else:
                 return main.TRUE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
 
     def del_link( self, node1, node2 ):
-        '''
-        delete a link from the mininet topology
-        NOTE: this uses a custom mn function
-        required params:
-            node1 = the string node name of the first endpoint of the link
-            node2 = the string node name of the second endpoint of the link
-        returns: main.FASLE on an error, else main.TRUE
-        '''
+        """
+           delete a link from the mininet topology
+           NOTE: this uses a custom mn function
+           required params:
+           node1 = the string node name of the first endpoint of the link
+           node2 = the string node name of the second endpoint of the link
+           returns: main.FASLE on an error, else main.TRUE"""
         command = "dellink " + str( node1 ) + " " + str( node2 )
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-            if re.search("no node named", response):
-                main.log.warn(response)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+            if re.search( "no node named", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("Error", response):
-                main.log.warn(response)
+            elif re.search( "Error", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("usage:", response):
-                main.log.warn(response)
+            elif re.search( "usage:", response ):
+                main.log.warn( response )
                 return main.FALSE
             else:
                 return main.TRUE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
 
     def add_host( self, hostname, **kwargs ):
-        '''
+        """
         Add a host to the mininet topology
         NOTE: this uses a custom mn function
         NOTE: cannot currently specify what type of host
@@ -893,515 +1027,603 @@
         optional key-value params
             switch = "switch name"
             returns: main.FASLE on an error, else main.TRUE
-        '''
-        switch = kwargs.get('switch', '')
+        """
+        switch = kwargs.get( 'switch', '' )
         command = "addhost " + str( hostname ) + " " + str( switch )
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-            if re.search("already exists!", response):
-                main.log.warn(response)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+            if re.search( "already exists!", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("doesnt exists!", response):
-                main.log.warn(response)
+            elif re.search( "doesnt exists!", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("Error", response):
-                main.log.warn(response)
+            elif re.search( "Error", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("usage:", response):
-                main.log.warn(response)
+            elif re.search( "usage:", response ):
+                main.log.warn( response )
                 return main.FALSE
             else:
                 return main.TRUE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
 
     def del_host( self, hostname ):
-        '''
-        delete a host from the mininet topology
-        NOTE: this uses a custom mn function
-        required params:
-            hostname = the string hostname
-            returns: main.FASLE on an error, else main.TRUE
-        '''
+        """
+           delete a host from the mininet topology
+           NOTE: this uses a custom mn function
+           required params:
+           hostname = the string hostname
+           returns: main.FASLE on an error, else main.TRUE"""
         command = "delhost " + str( hostname )
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-            if re.search("no host named", response):
-                main.log.warn(response)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+            if re.search( "no host named", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("Error", response):
-                main.log.warn(response)
+            elif re.search( "Error", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("usage:", response):
-                main.log.warn(response)
+            elif re.search( "usage:", response ):
+                main.log.warn( response )
                 return main.FALSE
             else:
                 return main.TRUE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
 
-    def disconnect(self):
-        main.log.info(self.name+": Disconnecting mininet...")
+    def disconnect( self ):
+        main.log.info( self.name + ": Disconnecting mininet..." )
         response = ''
         if self.handle:
             try:
-                response = self.execute(cmd="exit",prompt="(.*)",timeout=120)
-                response = self.execute(cmd="exit",prompt="(.*)",timeout=120)
-                self.handle.sendline("sudo mn -c")
+                response = self.execute(
+                    cmd="exit",
+                    prompt="(.*)",
+                    timeout=120 )
+                response = self.execute(
+                    cmd="exit",
+                    prompt="(.*)",
+                    timeout=120 )
+                self.handle.sendline( "sudo mn -c" )
                 response = main.TRUE
-            except pexpect.EOF:  
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+            except pexpect.EOF:
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 main.cleanup()
                 main.exit()
-        else :
-            main.log.error(self.name+": Connection failed to the host")
+        else:
+            main.log.error( self.name + ": Connection failed to the host" )
             response = main.FALSE
-        return response  
-  
-    def arping(self, src, dest, destmac):
-        self.handle.sendline('')
-        self.handle.expect(["mininet",pexpect.EOF,pexpect.TIMEOUT])
+        return response
 
-        self.handle.sendline(src + ' arping ' + dest)
+    def arping( self, src, dest, destmac ):
+        self.handle.sendline( '' )
+        self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
+
+        self.handle.sendline( src + ' arping ' + dest )
         try:
-            self.handle.expect([destmac,pexpect.EOF,pexpect.TIMEOUT])
-            main.log.info(self.name+": ARP successful")
-            self.handle.expect(["mininet",pexpect.EOF,pexpect.TIMEOUT])
+            self.handle.expect( [ destmac, pexpect.EOF, pexpect.TIMEOUT ] )
+            main.log.info( self.name + ": ARP successful" )
+            self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
             return main.TRUE
         except:
-            main.log.warn(self.name+": ARP FAILURE")
-            self.handle.expect(["mininet",pexpect.EOF,pexpect.TIMEOUT])
+            main.log.warn( self.name + ": ARP FAILURE" )
+            self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
             return main.FALSE
 
-    def decToHex(num):
-        return hex(num).split('x')[1]
-    
-    def getSwitchFlowCount(self, switch):
-        '''
-        return the Flow Count of the switch
-        '''
+    def decToHex( self, num ):
+        return hex( num ).split( 'x' )[ 1 ]
+
+    def getSwitchFlowCount( self, switch ):
+        """
+           return the Flow Count of the switch"""
         if self.handle:
             cmd = "sh ovs-ofctl dump-aggregate %s" % switch
             try:
-                response = self.execute(cmd=cmd, prompt="mininet>", timeout=10)
+                response = self.execute(
+                    cmd=cmd,
+                    prompt="mininet>",
+                    timeout=10 )
             except pexpect.EOF:
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + "     " + self.handle.before)
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + "     " + self.handle.before )
                 main.cleanup()
                 main.exit()
             pattern = "flow_count=(\d+)"
-            result = re.search(pattern, response, re.MULTILINE)
+            result = re.search( pattern, response, re.MULTILINE )
             if result is None:
-                main.log.info("Couldn't find flows on switch '', found: %s" % (switch, response))
+                main.log.info(
+                    "Couldn't find flows on switch %s, found: %s" %
+                    ( switch, response ) )
                 return main.FALSE
-            return result.group(1)
+            return result.group( 1 )
         else:
-            main.log.error("Connection failed to the Mininet host")
-    
-    def check_flows(self, sw, dump_format=None):
+            main.log.error( "Connection failed to the Mininet host" )
+
+    def check_flows( self, sw, dump_format=None ):
         if dump_format:
-          command = "sh ovs-ofctl -F " + dump_format + " dump-flows " + str(sw)
+            command = "sh ovs-ofctl -F " + \
+                dump_format + " dump-flows " + str( sw )
         else:
-          command = "sh ovs-ofctl dump-flows "+str(sw)
+            command = "sh ovs-ofctl dump-flows " + str( sw )
         try:
-            response=self.execute(cmd=command,prompt="mininet>",timeout=10)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
             return response
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         else:
-            main.log.info(response)
+            main.log.info( response )
 
-    def start_tcpdump(self, filename, intf = "eth0", port = "port 6633"):
-        '''
-        Runs tpdump on an intferface and saves the file
-        intf can be specified, or the default eth0 is used
-        '''
+    def start_tcpdump( self, filename, intf="eth0", port="port 6633" ):
+        """
+           Runs tpdump on an intferface and saves the file
+           intf can be specified, or the default eth0 is used"""
         try:
-            self.handle.sendline("")
-            self.handle.expect("mininet>")
-            self.handle.sendline("sh sudo tcpdump -n -i "+ intf + " " + port + " -w " + filename.strip() + "  &")
-            self.handle.sendline("")
-            i=self.handle.expect(['No\ssuch\device','listening\son',pexpect.TIMEOUT,"mininet>"],timeout=10)
-            main.log.warn(self.handle.before + self.handle.after)
-            self.handle.sendline("")
-            self.handle.expect("mininet>")
+            self.handle.sendline( "" )
+            self.handle.expect( "mininet>" )
+            self.handle.sendline(
+                "sh sudo tcpdump -n -i " +
+                intf +
+                " " +
+                port +
+                " -w " +
+                filename.strip() +
+                "  &" )
+            self.handle.sendline( "" )
+            i = self.handle.expect( [ 'No\ssuch\device',
+                                      'listening\son',
+                                      pexpect.TIMEOUT,
+                                      "mininet>" ],
+                                    timeout=10 )
+            main.log.warn( self.handle.before + self.handle.after )
+            self.handle.sendline( "" )
+            self.handle.expect( "mininet>" )
             if i == 0:
-                main.log.error(self.name + ": tcpdump - No such device exists. tcpdump attempted on: " + intf)
+                main.log.error(
+                    self.name +
+                    ": tcpdump - No such device exists. " +
+                    "tcpdump attempted on: " +
+                    intf )
                 return main.FALSE
             elif i == 1:
-                main.log.info(self.name + ": tcpdump started on " + intf)
+                main.log.info( self.name + ": tcpdump started on " + intf )
                 return main.TRUE
             elif i == 2:
-                main.log.error(self.name + ": tcpdump command timed out! Check interface name, given interface was: " + intf)
+                main.log.error(
+                    self.name +
+                    ": tcpdump command timed out! Check interface name," +
+                    " given interface was: " +
+                    intf )
                 return main.FALSE
-            elif i ==3: 
-                main.log.info(self.name +": " +  self.handle.before)
+            elif i == 3:
+                main.log.info( self.name + ": " + self.handle.before )
                 return main.TRUE
             else:
-                main.log.error(self.name + ": tcpdump - unexpected response")
+                main.log.error( self.name + ": tcpdump - unexpected response" )
             return main.FALSE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         except:
-            main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            main.log.info( self.name + ":" * 50 )
             main.log.error( traceback.print_exc() )
-            main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            main.log.info(":" * 50 )
             main.cleanup()
             main.exit()
 
-    def stop_tcpdump(self):
+    def stop_tcpdump( self ):
         "pkills tcpdump"
         try:
-            self.handle.sendline("sh sudo pkill tcpdump")
-            self.handle.expect("mininet>")
-            self.handle.sendline("")
-            self.handle.expect("mininet>")
+            self.handle.sendline( "sh sudo pkill tcpdump" )
+            self.handle.expect( "mininet>" )
+            self.handle.sendline( "" )
+            self.handle.expect( "mininet>" )
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         except:
-            main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            main.log.info( self.name + ":" * 50 )
             main.log.error( traceback.print_exc() )
-            main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            main.log.info(":" * 50 )
             main.cleanup()
             main.exit()
 
-    def compare_switches(self, topo, switches_json):
-        '''
-        Compare mn and onos switches
-        topo: sts TestONTopology object
-        switches_json: parsed json object from the onos devices api
+    def compare_switches( self, topo, switches_json ):
+        """
+           Compare mn and onos switches
+           topo: sts TestONTopology object
+            switches_json: parsed json object from the onos devices api
 
-        This uses the sts TestONTopology object
-
-        '''
-        import json
-        #main.log.debug("Switches_json string: ", switches_json)
-        output = {"switches":[]}
-        for switch in topo.graph.switches: #iterate through the MN topology and pull out switches and and port info
+           This uses the sts TestONTopology object"""
+        # main.log.debug( "Switches_json string: ", switches_json )
+        output = { "switches": [] }
+        # iterate through the MN topology and pull out switches and and port
+        # info
+        for switch in topo.graph.switches:
             ports = []
             for port in switch.ports.values():
-                ports.append({'of_port': port.port_no, 'mac': str(port.hw_addr).replace('\'',''), 'name': port.name})
-            output['switches'].append({"name": switch.name, "dpid": str(switch.dpid).zfill(16), "ports": ports })
+                ports.append( { 'of_port': port.port_no,
+                                'mac': str( port.hw_addr ).replace( '\'',
+                                                                    ''),
+                                'name': port.name } )
+            output[ 'switches' ].append( {
+                "name": switch.name,
+                "dpid": str( switch.dpid ).zfill( 16 ),
+                "ports": ports } )
 
-        #print "mn"
-        #print json.dumps(output, sort_keys=True,indent=4,separators=(',', ': '))
-        #print "onos"
-        #print json.dumps(switches_json, sort_keys=True,indent=4,separators=(',', ': '))
-
+        # print "mn"
+        # print json.dumps( output,
+        #                   sort_keys=True,
+        #                   indent=4,
+        #                   separators=( ',', ': ' ) )
+        # print "onos"
+        # print json.dumps( switches_json,
+        #                   sort_keys=True,
+        #                   indent=4,
+        #                   separators=( ',', ': ' ) )
 
         # created sorted list of dpid's in MN and ONOS for comparison
-        mnDPIDs=[]
-        for switch in output['switches']:
-            mnDPIDs.append(switch['dpid'])
+        mnDPIDs = []
+        for switch in output[ 'switches' ]:
+            mnDPIDs.append( switch[ 'dpid' ].lower() )
         mnDPIDs.sort()
-        #print "List of Mininet switch DPID's"
-        #print mnDPIDs
-        if switches_json == "":#if rest call fails
-            main.log.error(self.name + ".compare_switches(): Empty JSON object given from ONOS")
+        # print "List of Mininet switch DPID's"
+        # print mnDPIDs
+        if switches_json == "":  # if rest call fails
+            main.log.error(
+                self.name +
+                ".compare_switches(): Empty JSON object given from ONOS" )
             return main.FALSE
-        onos=switches_json
-        onosDPIDs=[]
+        onos = switches_json
+        onosDPIDs = []
         for switch in onos:
-            if switch['available'] == True:
-                onosDPIDs.append(switch['id'].replace(":",'').replace("of",''))
-            #else:
-                #print "Switch is unavailable:"
-                #print switch
+            if switch[ 'available' ]:
+                onosDPIDs.append(
+                    switch[ 'id' ].replace(
+                        ":",
+                        '' ).replace(
+                        "of",
+                        '' ).lower() )
+            # else:
+                # print "Switch is unavailable:"
+                # print switch
         onosDPIDs.sort()
-        #print "List of ONOS switch DPID's"
-        #print onosDPIDs
+        # print "List of ONOS switch DPID's"
+        # print onosDPIDs
 
-        if mnDPIDs!=onosDPIDs:
+        if mnDPIDs != onosDPIDs:
             switch_results = main.FALSE
-            main.log.report( "Switches in MN but not in ONOS:")
-            main.log.report( str([switch for switch in mnDPIDs if switch not in onosDPIDs]))
-            main.log.report( "Switches in ONOS but not in MN:")
-            main.log.report(  str([switch for switch in onosDPIDs if switch not in mnDPIDs]))
-        else:#list of dpid's match in onos and mn
-            #main.log.report("DEBUG: The dpid's of the switches in Mininet and ONOS match")
+            main.log.report( "Switches in MN but not in ONOS:" )
+            list1 = [ switch for switch in mnDPIDs if switch not in onosDPIDs ]
+            main.log.report( str( list1 ) )
+            main.log.report( "Switches in ONOS but not in MN:" )
+            list2 = [ switch for switch in onosDPIDs if switch not in mnDPIDs ]
+            main.log.report(str( list2 ) )
+        else:  # list of dpid's match in onos and mn
             switch_results = main.TRUE
         return switch_results
 
-
-
-    def compare_ports(self, topo, ports_json):
-        '''
+    def compare_ports( self, topo, ports_json ):
+        """
         Compare mn and onos ports
         topo: sts TestONTopology object
         ports_json: parsed json object from the onos ports api
 
-        Dependencies: 
+        Dependencies:
             1. This uses the sts TestONTopology object
             2. numpy - "sudo pip install numpy"
 
-        '''
-        #FIXME: this does not look for extra ports in ONOS, only checks that ONOS has what is in MN
-        import json
+        """
+        # FIXME: this does not look for extra ports in ONOS, only checks that
+        # ONOS has what is in MN
         from numpy import uint64
         ports_results = main.TRUE
-        output = {"switches":[]}
-        for switch in topo.graph.switches: #iterate through the MN topology and pull out switches and and port info
+        output = { "switches": [] }
+        # iterate through the MN topology and pull out switches and and port
+        # info
+        for switch in topo.graph.switches:
             ports = []
             for port in switch.ports.values():
-                #print port.hw_addr.toStr(separator = '')
+                # print port.hw_addr.toStr( separator='' )
                 tmp_port = {}
-                tmp_port['of_port'] = port.port_no
-                tmp_port['mac'] = str(port.hw_addr).replace('\'','')
-                tmp_port['name'] = port.name
-                tmp_port['enabled'] = port.enabled
+                tmp_port[ 'of_port' ] = port.port_no
+                tmp_port[ 'mac' ] = str( port.hw_addr ).replace( '\'', '' )
+                tmp_port[ 'name' ] = port.name
+                tmp_port[ 'enabled' ] = port.enabled
 
-                ports.append(tmp_port)
+                ports.append( tmp_port )
             tmp_switch = {}
-            tmp_switch['name'] = switch.name
-            tmp_switch['dpid'] = str(switch.dpid).zfill(16)
-            tmp_switch['ports'] = ports
+            tmp_switch[ 'name' ] = switch.name
+            tmp_switch[ 'dpid' ] = str( switch.dpid ).zfill( 16 )
+            tmp_switch[ 'ports' ] = ports
 
-            output['switches'].append(tmp_switch)
+            output[ 'switches' ].append( tmp_switch )
 
-
-        ################ports#############
-        for mn_switch in output['switches']:
+        # PORTS
+        for mn_switch in output[ 'switches' ]:
             mn_ports = []
             onos_ports = []
             switch_result = main.TRUE
-            for port in mn_switch['ports']:
-                if port['enabled'] == True:
-                    mn_ports.append(port['of_port'])
-                #else: #DEBUG only 
-                #    main.log.warn("Port %s on switch %s is down" % ( str(port['of_port']) , str(mn_switch['name'])) )
+            for port in mn_switch[ 'ports' ]:
+                if port[ 'enabled' ]:
+                    mn_ports.append( port[ 'of_port' ] )
             for onos_switch in ports_json:
-                #print "Iterating through a new switch as seen by ONOS"
-                #print onos_switch
-                if onos_switch['device']['available'] == True:
-                    if onos_switch['device']['id'].replace(':','').replace("of", '') == mn_switch['dpid']:
-                        for port in onos_switch['ports']:
-                            if port['isEnabled']:
-                                #print "Iterating through available ports on the switch"
-                                #print port
-                                if port['port'] == 'local':
-                                    #onos_ports.append('local')
-                                    onos_ports.append(long(uint64(-2)))
+                # print "Iterating through a new switch as seen by ONOS"
+                # print onos_switch
+                if onos_switch[ 'device' ][ 'available' ]:
+                    if onos_switch[ 'device' ][ 'id' ].replace(
+                            ':',
+                            '' ).replace(
+                            "of",
+                            '' ) == mn_switch[ 'dpid' ]:
+                        for port in onos_switch[ 'ports' ]:
+                            if port[ 'isEnabled' ]:
+                                if port[ 'port' ] == 'local':
+                                    # onos_ports.append( 'local' )
+                                    onos_ports.append( long( uint64( -2 ) ) )
                                 else:
-                                    onos_ports.append(int(port['port']))
-                                    '''
-                                else: #This is likely a new reserved port implemented
-                                    main.log.error("unkown port '" + str(port['port']) )
-                                    '''
-                           #else: #DEBUG
-                           #    main.log.warn("Port %s on switch %s is down" % ( str(port['port']) , str(onos_switch['device']['id'])) )
+                                    onos_ports.append( int( port[ 'port' ] ) )
                         break
-            mn_ports.sort(key=float)
-            onos_ports.sort(key=float)
-            #print "\nPorts for Switch %s:" % (switch['name'])
-            #print "\tmn_ports[] = ", mn_ports
-            #print "\tonos_ports[] = ", onos_ports
+            mn_ports.sort( key=float )
+            onos_ports.sort( key=float )
+            # print "\nPorts for Switch %s:" % ( mn_switch[ 'name' ] )
+            # print "\tmn_ports[] = ", mn_ports
+            # print "\tonos_ports[] = ", onos_ports
             mn_ports_log = mn_ports
             onos_ports_log = onos_ports
-            mn_ports = [x for x in mn_ports]
-            onos_ports = [x for x in onos_ports]
+            mn_ports = [ x for x in mn_ports ]
+            onos_ports = [ x for x in onos_ports ]
 
-            #TODO: handle other reserved port numbers besides LOCAL
-            #NOTE: Reserved ports
-            #   Local port: -2 in Openflow, ONOS shows 'local', we store as long(uint64(-2))
+            # TODO: handle other reserved port numbers besides LOCAL
+            # NOTE: Reserved ports
+            # Local port: -2 in Openflow, ONOS shows 'local', we store as
+            # long( uint64( -2 ) )
             for mn_port in mn_ports_log:
                 if mn_port in onos_ports:
-                    #don't set results to true here as this is just one of many checks and it might override a failure
-                    mn_ports.remove(mn_port)
-                    onos_ports.remove(mn_port)
-                #NOTE: OVS reports this as down since there is no link
+                    # don't set results to true here as this is just one of
+                    # many checks and it might override a failure
+                    mn_ports.remove( mn_port )
+                    onos_ports.remove( mn_port )
+                # NOTE: OVS reports this as down since there is no link
                 #      So ignoring these for now
-                #TODO: Come up with a better way of handling these
+                # TODO: Come up with a better way of handling these
                 if 65534 in mn_ports:
-                    mn_ports.remove(65534)
-                if long(uint64(-2)) in onos_ports:
-                    onos_ports.remove( long(uint64(-2))  )
-            if len(mn_ports):  #the ports of this switch don't match
+                    mn_ports.remove( 65534 )
+                if long( uint64( -2 ) ) in onos_ports:
+                    onos_ports.remove( long( uint64( -2 ) ) )
+            if len( mn_ports ):  # the ports of this switch don't match
                 switch_result = main.FALSE
-                main.log.warn("Ports in MN but not ONOS: " + str(mn_ports) )
-            if len(onos_ports):  #the ports of this switch don't match
+                main.log.warn( "Ports in MN but not ONOS: " + str( mn_ports ) )
+            if len( onos_ports ):  # the ports of this switch don't match
                 switch_result = main.FALSE
-                main.log.warn("Ports in ONOS but not MN: " + str(onos_ports) )
+                main.log.warn(
+                    "Ports in ONOS but not MN: " +
+                    str( onos_ports ) )
             if switch_result == main.FALSE:
-                main.log.report("The list of ports for switch %s(%s) does not match:" % (mn_switch['name'], mn_switch['dpid']) )
-                main.log.warn("mn_ports[]  =  " + str(mn_ports_log))
-                main.log.warn("onos_ports[] = " + str(onos_ports_log))
+                main.log.report(
+                    "The list of ports for switch %s(%s) does not match:" %
+                    ( mn_switch[ 'name' ], mn_switch[ 'dpid' ] ) )
+                main.log.warn( "mn_ports[]  =  " + str( mn_ports_log ) )
+                main.log.warn( "onos_ports[] = " + str( onos_ports_log ) )
             ports_results = ports_results and switch_result
         return ports_results
 
+    def compare_links( self, topo, links_json ):
+        """
+           Compare mn and onos links
+           topo: sts TestONTopology object
+           links_json: parsed json object from the onos links api
 
-
-
-    def compare_links(self, topo, links_json):
-        '''
-        Compare mn and onos links
-        topo: sts TestONTopology object
-        links_json: parsed json object from the onos links api
-
-        This uses the sts TestONTopology object
-
-        '''
-        #FIXME: this does not look for extra links in ONOS, only checks that ONOS has what is in MN
-        import json
+           This uses the sts TestONTopology object"""
+        # FIXME: this does not look for extra links in ONOS, only checks that
+        # ONOS has what is in MN
         link_results = main.TRUE
-        output = {"switches":[]}
+        output = { "switches": [] }
         onos = links_json
-        for switch in topo.graph.switches: #iterate through the MN topology and pull out switches and and port info
+        # iterate through the MN topology and pull out switches and and port
+        # info
+        for switch in topo.graph.switches:
             # print "Iterating though switches as seen by Mininet"
             # print switch
             ports = []
             for port in switch.ports.values():
-                #print port.hw_addr.toStr(separator = '')
-                ports.append({'of_port': port.port_no, 'mac': str(port.hw_addr).replace('\'',''), 'name': port.name})
-            output['switches'].append({"name": switch.name, "dpid": str(switch.dpid).zfill(16), "ports": ports })
-        #######Links########
+                # print port.hw_addr.toStr( separator='' )
+                ports.append( { 'of_port': port.port_no,
+                                'mac': str( port.hw_addr ).replace( '\'',
+                                                                    ''),
+                                'name': port.name } )
+            output[ 'switches' ].append( {
+                "name": switch.name,
+                "dpid": str( switch.dpid ).zfill( 16 ),
+                "ports": ports } )
+        # LINKS
 
-        mn_links = [link for link in topo.patch_panel.network_links if (link.port1.enabled and link.port2.enabled)]
-        #print "mn_links:"
-        #print mn_links
-        if 2*len(mn_links) == len(onos):
+        mn_links = [
+            link for link in topo.patch_panel.network_links if (
+                link.port1.enabled and link.port2.enabled ) ]
+        if 2 * len( mn_links ) == len( onos ):
             link_results = main.TRUE
         else:
             link_results = main.FALSE
-            main.log.report("Mininet has %i bidirectional links and ONOS has %i unidirectional links" % (len(mn_links), len(onos) ))
+            main.log.report(
+                "Mininet has %i bidirectional links and " +
+                "ONOS has %i unidirectional links" %
+                ( len( mn_links ), len( onos ) ) )
 
-
-        # iterate through MN links and check if an ONOS link exists in both directions
-        # NOTE: Will currently only show mn links as down if they are cut through STS. 
-        #       We can either do everything through STS or wait for up_network_links 
-        #       and down_network_links to be fully implemented.
-        for link in mn_links: 
-            #print "Link: %s" % link
-            #TODO: Find a more efficient search method
+        # iterate through MN links and check if an ONOS link exists in
+        # both directions
+        # NOTE: Will currently only show mn links as down if they are
+        #       cut through STS. We can either do everything through STS or
+        #       wait for up_network_links and down_network_links to be
+        #       fully implemented.
+        for link in mn_links:
+            # print "Link: %s" % link
+            # TODO: Find a more efficient search method
             node1 = None
             port1 = None
             node2 = None
             port2 = None
             first_dir = main.FALSE
             second_dir = main.FALSE
-            for switch in output['switches']:
-                #print "Switch: %s" % switch['name']
-                if switch['name'] == link.node1.name:
-                    node1 = switch['dpid']
-                    for port in switch['ports']:
-                        if str(port['name']) == str(link.port1):
-                            port1 = port['of_port'] 
+            for switch in output[ 'switches' ]:
+                # print "Switch: %s" % switch[ 'name' ]
+                if switch[ 'name' ] == link.node1.name:
+                    node1 = switch[ 'dpid' ]
+                    for port in switch[ 'ports' ]:
+                        if str( port[ 'name' ] ) == str( link.port1 ):
+                            port1 = port[ 'of_port' ]
                     if node1 is not None and node2 is not None:
                         break
-                if switch['name'] == link.node2.name:
-                    node2 = switch['dpid']
-                    for port in switch['ports']: 
-                        if str(port['name']) == str(link.port2):
-                            port2 = port['of_port'] 
+                if switch[ 'name' ] == link.node2.name:
+                    node2 = switch[ 'dpid' ]
+                    for port in switch[ 'ports' ]:
+                        if str( port[ 'name' ] ) == str( link.port2 ):
+                            port2 = port[ 'of_port' ]
                     if node1 is not None and node2 is not None:
                         break
 
-
             for onos_link in onos:
-                onos_node1 = onos_link['src']['device'].replace(":",'').replace("of", '')
-                onos_node2 = onos_link['dst']['device'].replace(":",'').replace("of", '')
-                onos_port1 = onos_link['src']['port']
-                onos_port2 = onos_link['dst']['port']
+                onos_node1 = onos_link[ 'src' ][ 'device' ].replace(
+                    ":",
+                    '' ).replace(
+                    "of",
+                    '' )
+                onos_node2 = onos_link[ 'dst' ][ 'device' ].replace(
+                    ":",
+                    '' ).replace(
+                    "of",
+                    '' )
+                onos_port1 = onos_link[ 'src' ][ 'port' ]
+                onos_port2 = onos_link[ 'dst' ][ 'port' ]
 
-                #print "Checking ONOS for link %s/%s -> %s/%s and" % (node1, port1, node2, port2)
-                #print "Checking ONOS for link %s/%s -> %s/%s" % (node2, port2, node1, port1)
                 # check onos link from node1 to node2
-                if str(onos_node1) == str(node1) and str(onos_node2) == str(node2):
-                    if int(onos_port1) == int(port1) and int(onos_port2) == int(port2):
+                if str( onos_node1 ) == str( node1 ) and str(
+                        onos_node2 ) == str( node2 ):
+                    if int( onos_port1 ) == int( port1 ) and int(
+                            onos_port2 ) == int( port2 ):
                         first_dir = main.TRUE
                     else:
-                        main.log.warn('The port numbers do not match for ' +str(link) +\
-                                ' between ONOS and MN. When cheking ONOS for link '+\
-                                '%s/%s -> %s/%s' % (node1, port1, node2, port2)+\
-                                ' ONOS has the values %s/%s -> %s/%s' %\
-                                (onos_node1, onos_port1, onos_node2, onos_port2))
+                        main.log.warn(
+                            'The port numbers do not match for ' +
+                            str( link ) +
+                            ' between ONOS and MN. When cheking ONOS for ' +
+                            'link %s/%s -> %s/%s' %
+                            ( node1,
+                              port1,
+                              node2,
+                              port2 ) +
+                            ' ONOS has the values %s/%s -> %s/%s' %
+                            ( onos_node1,
+                              onos_port1,
+                              onos_node2,
+                              onos_port2 ) )
 
                 # check onos link from node2 to node1
-                elif ( str(onos_node1) == str(node2) and str(onos_node2) == str(node1) ):
-                    if ( int(onos_port1) == int(port2) and int(onos_port2) == int(port1) ):
+                elif ( str( onos_node1 ) == str( node2 ) and
+                        str( onos_node2 ) == str( node1 ) ):
+                    if ( int( onos_port1 ) == int( port2 )
+                         and int( onos_port2 ) == int( port1 ) ):
                         second_dir = main.TRUE
                     else:
-                        main.log.warn('The port numbers do not match for ' +str(link) +\
-                                ' between ONOS and MN. When cheking ONOS for link '+\
-                                '%s/%s -> %s/%s' % (node2, port2, node1, port1)+\
-                                ' ONOS has the values %s/%s -> %s/%s' %\
-                                (onos_node2, onos_port2, onos_node1, onos_port1))
-                else:#this is not the link you're looking for
+                        main.log.warn(
+                            'The port numbers do not match for ' +
+                            str( link ) +
+                            ' between ONOS and MN. When cheking ONOS for ' +
+                            'link %s/%s -> %s/%s' %
+                            ( node2,
+                              port2,
+                              node1,
+                              port1 ) +
+                            ' ONOS has the values %s/%s -> %s/%s' %
+                            ( onos_node2,
+                              onos_port2,
+                              onos_node1,
+                              onos_port1 ) )
+                else:  # this is not the link you're looking for
                     pass
             if not first_dir:
-                main.log.report('ONOS does not have the link %s/%s -> %s/%s' % (node1, port1, node2, port2))
+                main.log.report(
+                    'ONOS does not have the link %s/%s -> %s/%s' %
+                    ( node1, port1, node2, port2 ) )
             if not second_dir:
-                main.log.report('ONOS does not have the link %s/%s -> %s/%s' % (node2, port2, node1, port1))
+                main.log.report(
+                    'ONOS does not have the link %s/%s -> %s/%s' %
+                    ( node2, port2, node1, port1 ) )
             link_results = link_results and first_dir and second_dir
         return link_results
 
+    def get_hosts( self ):
+        """
+           Returns a list of all hosts
+           Don't ask questions just use it"""
+        self.handle.sendline( "" )
+        self.handle.expect( "mininet>" )
 
-    def get_hosts(self):
-        '''
-        Returns a list of all hosts
-        Don't ask questions just use it
-        '''
-        self.handle.sendline("")
-        self.handle.expect("mininet>")
-        
-        self.handle.sendline("py [ host.name for host in net.hosts ]")
-        self.handle.expect("mininet>")
+        self.handle.sendline( "py [ host.name for host in net.hosts ]" )
+        self.handle.expect( "mininet>" )
 
         handle_py = self.handle.before
-        handle_py = handle_py.split("]\r\n",1)[1]
+        handle_py = handle_py.split( "]\r\n", 1 )[ 1 ]
         handle_py = handle_py.rstrip()
 
-        self.handle.sendline("")
-        self.handle.expect("mininet>")
+        self.handle.sendline( "" )
+        self.handle.expect( "mininet>" )
 
-        host_str = handle_py.replace("]", "")
-        host_str = host_str.replace("'", "")
-        host_str = host_str.replace("[", "")
-        host_list = host_str.split(",")
+        host_str = handle_py.replace( "]", "" )
+        host_str = host_str.replace( "'", "" )
+        host_str = host_str.replace( "[", "" )
+        host_list = host_str.split( "," )
 
-        return host_list 
+        return host_list
 
-
-    def update(self):
-        '''
-        updates the port address and status information for each port in mn
-        '''
-        #TODO: Add error checking. currently the mininet command has no output
-        main.log.info("Updateing MN port information")
+    def update( self ):
+        """
+           updates the port address and status information for
+           each port in mn"""
+        # TODO: Add error checking. currently the mininet command has no output
+        main.log.info( "Updateing MN port information" )
         try:
-            self.handle.sendline("")
-            self.handle.expect("mininet>")
+            self.handle.sendline( "" )
+            self.handle.expect( "mininet>" )
 
-            self.handle.sendline("update")
-            self.handle.expect("update")
-            self.handle.expect("mininet>")
+            self.handle.sendline( "update" )
+            self.handle.expect( "update" )
+            self.handle.expect( "mininet>" )
 
-            self.handle.sendline("")
-            self.handle.expect("mininet>")
+            self.handle.sendline( "" )
+            self.handle.expect( "mininet>" )
 
             return main.TRUE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
 
 if __name__ != "__main__":
     import sys
-    sys.modules[__name__] = MininetCliDriver()
-
+    sys.modules[ __name__ ] = MininetCliDriver()
diff --git a/TestON/drivers/common/cli/emulator/remotemininetdriver.py b/TestON/drivers/common/cli/emulator/remotemininetdriver.py
index 1795a16..48d3389 100644
--- a/TestON/drivers/common/cli/emulator/remotemininetdriver.py
+++ b/TestON/drivers/common/cli/emulator/remotemininetdriver.py
@@ -16,30 +16,23 @@
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
-    along with TestON.  If not, see <http://www.gnu.org/licenses/>.		
+    along with TestON.  If not, see <http://www.gnu.org/licenses/>.
 
 
 MininetCliDriver is the basic driver which will handle the Mininet functions
 '''
 import traceback
 import pexpect
-import struct
-import fcntl
-import os
-import signal
 import re
 import sys
-import core.teston
 sys.path.append("../")
 from drivers.common.cli.emulatordriver import Emulator
-from drivers.common.clidriver import CLI
-from time import time
 
 class RemoteMininetDriver(Emulator):
     '''
     RemoteMininetCliDriver is the basic driver which will handle the Mininet functions
-    The main different between this and the MininetCliDriver is that this one does not build the mininet. 
-    It assumes that there is already a mininet running on the target. 
+    The main different between this and the MininetCliDriver is that this one does not build the mininet.
+    It assumes that there is already a mininet running on the target.
     '''
     def __init__(self):
         super(Emulator, self).__init__()
@@ -51,25 +44,25 @@
         #,user_name, ip_address, pwd,options):
         # Here the main is the TestON instance after creating all the log handles.
         for key in connectargs:
-            vars(self)[key] = connectargs[key]       
-        
+            vars(self)[key] = connectargs[key]
+
         self.name = self.options['name']
         self.handle = super(RemoteMininetDriver, self).connect(user_name = self.user_name, ip_address = self.ip_address,port = None, pwd = self.pwd)
-        
+
         self.ssh_handle = self.handle
-        
-        # Copying the readme file to process the 
+
+        # Copying the readme file to process the
         if self.handle :
             return main.TRUE
 
         else :
-            main.log.error("Connection failed to the host "+self.user_name+"@"+self.ip_address) 
+            main.log.error("Connection failed to the host "+self.user_name+"@"+self.ip_address)
             main.log.error("Failed to connect to the Mininet")
             return main.FALSE
 
 #*********************************************************************************************
 #*********************************************************************************************
-# checkForLoss will determine if any of the pings had any packets lost during the course of 
+# checkForLoss will determine if any of the pings had any packets lost during the course of
 # the pingLong.
 #*********************************************************************************************
 #*********************************************************************************************
@@ -84,7 +77,6 @@
         #EX: 393 packets transmitted, 380 received, 3% packet loss, time 78519ms
         # we may need to return a float to get around rounding errors
 
-        import os
         self.handle.sendline("")
         self.handle.expect("\$")
         #Clear any output waiting in the bg from killing pings
@@ -107,15 +99,15 @@
 
     def pingLong(self,**pingParams):
         '''
-        Starts a continuous ping on the mininet host outputing to a file in the /tmp dir. 
+        Starts a continuous ping on the mininet host outputing to a file in the /tmp dir.
         '''
         self.handle.sendline("")
         self.handle.expect("\$")
         args = utilities.parse_args(["SRC","TARGET","PINGTIME"],**pingParams)
         precmd = "sudo rm /tmp/ping." + args["SRC"]
         self.execute(cmd=precmd,prompt="(.*)",timeout=10)
-        command = "sudo mininet/util/m " + args["SRC"] + " ping "+args ["TARGET"]+" -i .2 -w " + str(args['PINGTIME']) + " > /tmp/ping." + args["SRC"] + " &"
-        main.log.info( command ) 
+        command = "sudo mininet/util/m " + args["SRC"] + " ping "+args ["TARGET"]+" -i .2 -w " + str(args['PINGTIME']) + " -D > /tmp/ping." + args["SRC"] + " &"
+        main.log.info( command )
         self.execute(cmd=command,prompt="(.*)",timeout=10)
         self.handle.sendline("")
         self.handle.expect("\$")
@@ -135,33 +127,28 @@
         self.handle.sendline("")
         self.handle.expect("\$")
         if re.search('Unreachable', result ):
-            main.log.info("Unreachable found in ping logs...") 
+            main.log.info("Unreachable found in ping logs...")
             return main.FALSE
-        elif re.search('64\sbytes', result): 
-            main.log.info("Pings look good") 
+        elif re.search('64\sbytes', result):
+            main.log.info("Pings look good")
             return main.TRUE
-        else: 
-            main.log.info("No, or faulty ping data...") 
+        else:
+            main.log.info("No, or faulty ping data...")
             return main.FALSE
-         
+
     def pingKill(self, testONUser, testONIP):
         '''
         Kills all continuous ping processes.
         Then copies all the ping files to the TestStation.
         '''
-        import time
         self.handle.sendline("")
         self.handle.expect("\$")
-        command = "sudo kill -SIGINT `pgrep ping`" 
-        main.log.info( command ) 
+        command = "sudo kill -SIGINT `pgrep ping`"
+        main.log.info( command )
         self.execute(cmd=command,prompt="(.*)",timeout=10)
-        #Commenting out in case TestON and MN are on the same machine. scp overrights the file anyways
-        #main.log.info( "Removing old ping data" )
-        #command = "rm /tmp/ping.*"
-        #os.popen(command) 
-        #time.sleep(2)      
+
         main.log.info( "Transferring ping files to TestStation" )
-        command = "scp /tmp/ping.* "+ str(testONUser) + "@" + str(testONIP) + ":/tmp/" 
+        command = "scp /tmp/ping.* "+ str(testONUser) + "@" + str(testONIP) + ":/tmp/"
         self.execute(cmd=command,prompt="100%",timeout=20)
         #Make sure the output is cleared
         self.handle.sendline("")
@@ -176,9 +163,8 @@
             return main.FALSE
         else:
             return main.TRUE
-    
+
     def pingLongKill(self):
-        import time
         self.handle.sendline("")
         self.handle.expect("\$")
         command = "sudo kill -SIGING `pgrep ping`"
@@ -187,7 +173,7 @@
         self.handle.sendline("")
         self.handle.expect("\$")
         return main.TRUE
-       
+
     def pingHostOptical(self,**pingParams):
         '''
         This function is only for Packey Optical related ping
@@ -228,31 +214,31 @@
             return main.FALSE
 
     def pingHost(self,**pingParams):
-        ''' 
-        Pings between two hosts on remote mininet  
-        ''' 
+        '''
+        Pings between two hosts on remote mininet
+        '''
         self.handle.sendline("")
         self.handle.expect("\$")
         args = utilities.parse_args(["SRC","TARGET"],**pingParams)
         #command = "mininet/util/m " + args["SRC"] + " ping "+args ["TARGET"]+" -c 4 -W 1 -i .2"
         command = "mininet/util/m " + args["SRC"] + " ping "+args ["TARGET"]+" -c 4 -W 1 -i .2"
-        main.log.info ( command ) 
+        main.log.info ( command )
         response = self.execute(cmd=command,prompt="rtt",timeout=10 )
         #self.handle.sendline("")
         #self.handle.expect("\$")
         if utilities.assert_matches(expect=',\s0\%\spacket\sloss',actual=response,onpass="No Packet loss",onfail="Host is not reachable"):
             main.log.info("NO PACKET LOSS, HOST IS REACHABLE")
-            main.last_result = main.TRUE 
+            main.last_result = main.TRUE
             return main.TRUE
         else :
             main.log.error("PACKET LOST, HOST IS NOT REACHABLE")
             main.last_result = main.FALSE
             return main.FALSE
-        
-    
+
+
     def checknum(self,num):
         '''
-        Verifies the correct number of switches are running 
+        Verifies the correct number of switches are running
         '''
         if self.handle :
             self.handle.sendline("")
@@ -261,7 +247,7 @@
             self.handle.expect("wc")
             self.handle.expect("\$")
             response = self.handle.before
-            self.handle.sendline('ps -ef | grep "bash -ms mininet:sw" | grep -v color | wc -l') 
+            self.handle.sendline('ps -ef | grep "bash -ms mininet:sw" | grep -v color | wc -l')
             self.handle.expect("color")
             self.handle.expect("\$")
             response2 = self.handle.before
@@ -274,10 +260,10 @@
             else:
                 return main.FALSE
         else :
-            main.log.error("Connection failed to the host") 
+            main.log.error("Connection failed to the host")
 
     def start_tcpdump(self, filename, intf = "eth0", port = "port 6633", user="admin"):
-        ''' 
+        '''
         Runs tpdump on an intferface and saves the file
         intf can be specified, or the default eth0 is used
         '''
@@ -297,7 +283,7 @@
             elif i == 2:
                 main.log.error(self.name + ": tcpdump command timed out! Check interface name, given interface was: " + intf)
                 return main.FALSE
-            elif i ==3: 
+            elif i ==3:
                 main.log.info(self.name +": " +  self.handle.before)
                 return main.TRUE
             else:
@@ -336,7 +322,7 @@
 
     def run_optical_mn_script(self):
         '''
-            This function is only meant for Packet Optical. 
+            This function is only meant for Packet Optical.
             It runs the python script "optical.py" to create the packet layer(mn)
             topology
         '''
@@ -354,9 +340,9 @@
             return main.FALSE
 
     def disconnect(self):
-        '''    
-        Called at the end of the test to disconnect the handle.    
-        '''    
+        '''
+        Called at the end of the test to disconnect the handle.
+        '''
         response = ''
         #print "Disconnecting Mininet"
         if self.handle:
@@ -372,57 +358,40 @@
 
     def get_flowTable(self, protoVersion, sw):
         #TODO document usage
-        #FIXME: clean up print statements and such
+        #TODO add option to look at cookies. ignoreing them for now
         self.handle.sendline("cd")
         self.handle.expect(["\$",pexpect.EOF,pexpect.TIMEOUT])
-        #TODO: Write seperate versions of the function for this, possibly a string that tells it which switch is in use?
-        #For 1.0 version of OVS
-        #command = "sudo ovs-ofctl dump-flows " + sw + " | awk '{OFS=\",\" ; print $1 $6 $7 }' |sort -n -k1"
-        #for 1.3 version of OVS
-        #command = "sudo ovs-ofctl dump-flows " + sw + " | awk '{OFS=\",\" ; print $1 $3 $7 $8}' |sort -n -k1"
+        #print "get_flowTable(" + str(protoVersion) +" " + str(sw) +")"
         #NOTE: Use format to force consistent flow table output across versions
         if protoVersion==1.0:
-            command = "sudo ovs-ofctl dump-flows " + sw + " -F OpenFlow10-table_id | awk '{OFS=\",\" ; print $1  $3  $6  $7  $8}' |sort -n -k1"
+            command = "sudo ovs-ofctl dump-flows " + sw + " -F OpenFlow10-table_id | awk '{OFS=\",\" ; print $1  $3  $6  $7  $8}' | cut -d ',' -f 2- | sort -n -k1 -r"
             self.handle.sendline(command)
-            self.handle.expect(["sort -n -k1",pexpect.EOF,pexpect.TIMEOUT])
+            self.handle.expect(["k1 -r",pexpect.EOF,pexpect.TIMEOUT])
             self.handle.expect(["OFPST_FLOW",pexpect.EOF,pexpect.TIMEOUT])
             response = self.handle.before
             #print "response=", response
             return response
         elif protoVersion==1.3:
-            command = "sudo ovs-ofctl dump-flows " + sw + " -O OpenFlow13  | awk '{OFS=\",\" ; print $1  $3  $6  $7}' |sort -n -k1" 
+            command = "sudo ovs-ofctl dump-flows " + sw + " -O OpenFlow13  | awk '{OFS=\",\" ; print $1  $3  $6  $7}' | cut -d ',' -f 2- | sort -n -k1 -r"
             self.handle.sendline(command)
-            #print "ovs-vsctl Command sent status."
-            #self.handle.expect(["sort -n -k1",pexpect.EOF,pexpect.TIMEOUT])
-            #print "sort return status: " 
-            #print self.handle.expect(["sort -n -k1",pexpect.EOF,pexpect.TIMEOUT])
-            #print self.handle.before
+            self.handle.expect(["k1 -r",pexpect.EOF,pexpect.TIMEOUT])
             self.handle.expect(["OFPST_FLOW",pexpect.EOF,pexpect.TIMEOUT])
-            #print "OFPST_FLOW expected status: " 
-            #print self.handle.expect(["OFPST_FLOW",pexpect.EOF,pexpect.TIMEOUT])
-            #print self.handle.before
             response = self.handle.before
             #print "response=", response
-            return response 
-        
+            return response
+        else:
+            main.log.error("Unknown  protoVersion in get_flowTable(). given: ("+str(type(protoVersion))+") '"+str(protoVersion)+"'")
+
 
     def flow_comp(self,flow1,flow2):
-        #print "Inside flow compare function"
-        #print "Flow1 Table:"
-        #for flow in flow1:
-            #print flow1
-        #print "Flow2 Table"
-        #for flow in flow2:
-            #print flow2
-
         if flow1==flow2:
             return main.TRUE
         else:
             main.log.info("Flow tables do not match, printing tables:")
-            #main.log.info("Flow Table 1:")
-            #main.log.info(flow1)
-            #main.log.info("Flow Table 2:")
-            #main.log.info(flow2)
+            main.log.info("Flow Table 1:")
+            main.log.info(flow1)
+            main.log.info("Flow Table 2:")
+            main.log.info(flow2)
             return main.FALSE
 
     def setIpTablesOUTPUT(self, dst_ip, dst_port, action='add', packet_type='tcp',rule='DROP'):
@@ -432,8 +401,8 @@
         Usage:
         * specify action ('add' or 'remove')
           when removing, pass in the same argument as you would add. It will
-          delete that specific rule. 
-        * specify the destination ip to block with dst_ip 
+          delete that specific rule.
+        * specify the destination ip to block with dst_ip
         * specify destination port to block to dst_port
         * optional packet type to block (default tcp)
         * optional iptables rule (default DROP)
@@ -464,8 +433,8 @@
             return
         else:
 
-            #If there is no existing rule in the iptables, we will see an 
-            #'iptables:'... message. We expect to see this message. 
+            #If there is no existing rule in the iptables, we will see an
+            #'iptables:'... message. We expect to see this message.
             #Otherwise, if there IS an existing rule, we will get the prompt
             # back, hence why we expect $ for remove type. We want to remove
             # an already existing rule
@@ -473,7 +442,7 @@
             if action_type == 'add':
                 #NOTE: "iptables:" expect is a result of return from the command
                 #      iptables -C ...
-                #      Any changes by the iptables command return string 
+                #      Any changes by the iptables command return string
                 #      will result in failure of the function. (deemed unlikely
                 #      at the time of writing this function)
                 #Check for existing rules on current input
@@ -505,7 +474,7 @@
                 match_result = main.TRUE
             else:
                 match_result = main.FALSE
-            #If match_result is main.TRUE, it means there is no matching rule. 
+            #If match_result is main.TRUE, it means there is no matching rule.
 
             #If tables does not exist and expected prompt is returned, go ahead and
             #add iptables rule
diff --git a/TestON/drivers/common/cli/onosclidriver.py b/TestON/drivers/common/cli/onosclidriver.py
index a6cf341..838e6f4 100644
--- a/TestON/drivers/common/cli/onosclidriver.py
+++ b/TestON/drivers/common/cli/onosclidriver.py
@@ -18,13 +18,10 @@
 '''
 
 import sys
-import time
 import pexpect
 import re
 import traceback
-import os.path
-import pydoc
-import re
+#import os.path
 sys.path.append("../")
 from drivers.common.clidriver import CLI
 
@@ -172,7 +169,18 @@
             main.cleanup()
             main.exit()
         
-    def start_onos_cli(self, ONOS_ip):
+    def start_onos_cli(self, ONOS_ip, karafTimeout=""):
+        '''
+        karafTimeout is an optional arugument. karafTimeout value passed by user would be used to set the 
+        current karaf shell idle timeout. Note that when ever this property is modified the shell will exit and
+        the subsequent login would reflect new idle timeout.
+        Below is an example to start a session with 60 seconds idle timeout (input value is in milliseconds):
+          
+        tValue = "60000"
+        main.ONOScli1.start_onos_cli(ONOS_ip, karafTimeout=tValue)
+        
+        Note: karafTimeout is left as str so that this could be read and passed to start_onos_cli from PARAMS file as str.
+        '''
         try:
             self.handle.sendline("")
             x = self.handle.expect([
@@ -190,6 +198,11 @@
 
             if i == 0:
                 main.log.info(str(ONOS_ip)+" CLI Started successfully")
+                if karafTimeout:
+                    self.handle.sendline("config:property-set -p org.apache.karaf.shell sshIdleTimeout "+karafTimeout)
+                    self.handle.expect("\$")
+                    self.handle.sendline("onos -w "+str(ONOS_ip))
+                    self.handle.expect("onos>")
                 return main.TRUE
             else:
                 #If failed, send ctrl+c to process and try again
@@ -201,6 +214,11 @@
                 if i == 0:
                     main.log.info(str(ONOS_ip)+" CLI Started "+
                         "successfully after retry attempt")
+                    if karafTimeout:
+                        self.handle.sendline("config:property-set -p org.apache.karaf.shell sshIdleTimeout "+karafTimeout)
+                        self.handle.expect("\$")
+                        self.handle.sendline("onos -w "+str(ONOS_ip))
+			self.handle.expect("onos>")
                     return main.TRUE
                 else:
                     main.log.error("Connection to CLI "+\
@@ -508,6 +526,33 @@
             main.cleanup()
             main.exit()
 
+       
+    def balance_masters(self):
+        '''
+        This balances the devices across all controllers
+        by issuing command: 'onos> onos:balance-masters'
+        If required this could be extended to return devices balanced output.
+        '''
+        try:
+            self.handle.sendline("")
+            self.handle.expect("onos>")
+
+            self.handle.sendline("onos:balance-masters")
+            self.handle.expect("onos>")
+            return main.TRUE
+
+        except pexpect.EOF:
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":    " + self.handle.before)
+            main.cleanup()
+            main.exit()
+        except:
+            main.log.info(self.name+" ::::::")
+            main.log.error( traceback.print_exc())
+            main.log.info(self.name+" ::::::")
+            main.cleanup()
+            main.exit()
+
     def links(self, json_format=True):
         '''
         Lists all core links
@@ -693,7 +738,38 @@
             main.log.info(self.name+" ::::::")
             main.cleanup()
             main.exit()
-    
+
+    def roles_not_null(self):
+        '''
+        Iterates through each device and checks if there is a master assigned
+        Returns: main.TRUE if each device has a master
+                 main.FALSE any device has no master
+        '''
+        try:
+            import json
+            raw_roles = self.roles()
+            roles_json = json.loads(raw_roles)
+            #search json for the device with id then return the device
+            for device in roles_json:
+                #print device
+                if device['master'] == "none":
+                    main.log.warn("Device has no master: " + str(device) )
+                    return main.FALSE
+            return main.TRUE
+
+        except pexpect.EOF:
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":    " + self.handle.before)
+            main.cleanup()
+            main.exit()
+        except:
+            main.log.info(self.name+" ::::::")
+            main.log.error( traceback.print_exc())
+            main.log.info(self.name+" ::::::")
+            main.cleanup()
+            main.exit()
+
+
     def paths(self, src_id, dst_id):
         '''
         Returns string of paths, and the cost.
@@ -875,7 +951,7 @@
             handle = self.handle.before
             #print "handle =", handle
 
-            main.log.info("Intent installed between "+
+            main.log.info("Host intent installed between "+
                     str(host_id_one) + " and " + str(host_id_two))
 
             return handle
@@ -1027,7 +1103,7 @@
 
             if i == 0:
                 main.log.error("Error in adding point-to-point intent")
-                return handle
+                return main.FALSE
             else:
                 return main.TRUE
 
@@ -1357,6 +1433,9 @@
             
             if num_mult:
                 cmd += " " + str(num_mult)
+                #If app id is specified, then num_mult 
+                #must exist because of the way this command
+                #takes in arguments
                 if app_id:
                     cmd += " " + str(app_id)
             
@@ -1383,7 +1462,7 @@
                     #Append the first result of second parse
                     lat_result.append(result[1].split(" ")[0])
 
-                print lat_result 
+                main.log.info(lat_result) 
                 return lat_result 
             else:
                 return main.TRUE
@@ -1713,7 +1792,7 @@
         onos_node is the ip of one of the onos nodes in the cluster
         role must be either master, standby, or none
 
-        Returns main.TRUE or main.FALSE based argument varification.
+        Returns main.TRUE or main.FALSE based on argument verification.
             When device-role supports errors this should be extended to
             support that output
         '''
@@ -1805,5 +1884,233 @@
             main.cleanup()
             main.exit()
 
+    def election_test_leader(self):
+        '''
+         * CLI command to get the current leader for the Election test application.
+         #NOTE: Requires installation of the onos-app-election feature
+         Returns: Node IP of the leader if one exists
+                  None if none exists
+                  Main.FALSE on error
+        '''
+        try:
+            self.handle.sendline("election-test-leader")
+            self.handle.expect("election-test-leader")
+            self.handle.expect("onos>")
+            response = self.handle.before
+            #Leader
+            node_search = re.search("The\scurrent\sleader\sfor\sthe\sElection\sapp\sis\s(?P<node>.+)\.", response)
+            if node_search:
+                node = node_search.group('node')
+                main.log.info("Election-test-leader on "+str(self.name)+" found " + node + " as the leader")
+                return node
+            #no leader
+            null_search = re.search("There\sis\scurrently\sno\sleader\selected\sfor\sthe\sElection\sapp", response)
+            if null_search:
+                main.log.info("Election-test-leader found no leader on " + self.name )
+                return None
+            #error
+            if re.search("Command\snot\sfound", response):
+                main.log.error("Election app is not loaded on " + self.name)
+                return main.FALSE
+            else:
+                main.log.error("Error in election_test_leader: unexpected response")
+                main.log.error( repr(response) )
+                return main.FALSE
+
+        except pexpect.EOF:
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":    " + self.handle.before)
+            main.cleanup()
+            main.exit()
+        except:
+            main.log.info(self.name+" ::::::")
+            main.log.error( traceback.print_exc())
+            main.log.info(self.name+" ::::::")
+            main.cleanup()
+            main.exit()
+
+    def election_test_run(self):
+        '''
+         * CLI command to run for leadership of the Election test application.
+         #NOTE: Requires installation of the onos-app-election feature
+         Returns: Main.TRUE on success
+                  Main.FALSE on error
+        '''
+        try:
+            self.handle.sendline("election-test-run")
+            self.handle.expect("election-test-run")
+            self.handle.expect("onos>")
+            response = self.handle.before
+            #success
+            search = re.search("Entering\sleadership\selections\sfor\sthe\sElection\sapp.", response)
+            if search:
+                main.log.info(self.name + " entering leadership elections for the Election app.")
+                return main.TRUE
+            #error
+            if re.search("Command\snot\sfound", response):
+                main.log.error("Election app is not loaded on " + self.name)
+                return main.FALSE
+            else:
+                main.log.error("Error in election_test_run: unexpected response")
+                main.log.error( repr(response) )
+                return main.FALSE
+
+        except pexpect.EOF:
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":    " + self.handle.before)
+            main.cleanup()
+            main.exit()
+        except:
+            main.log.info(self.name+" ::::::")
+            main.log.error( traceback.print_exc())
+            main.log.info(self.name+" ::::::")
+            main.cleanup()
+            main.exit()
+
+    def election_test_withdraw(self):
+        '''
+         * CLI command to withdraw the local node from leadership election for
+         * the Election test application.
+         #NOTE: Requires installation of the onos-app-election feature
+         Returns: Main.TRUE on success
+                  Main.FALSE on error
+        '''
+        try:
+            self.handle.sendline("election-test-withdraw")
+            self.handle.expect("election-test-withdraw")
+            self.handle.expect("onos>")
+            response = self.handle.before
+            #success
+            search = re.search("Withdrawing\sfrom\sleadership\selections\sfor\sthe\sElection\sapp.", response)
+            if search:
+                main.log.info(self.name + " withdrawing from leadership elections for the Election app.")
+                return main.TRUE
+            #error
+            if re.search("Command\snot\sfound", response):
+                main.log.error("Election app is not loaded on " + self.name)
+                return main.FALSE
+            else:
+                main.log.error("Error in election_test_withdraw: unexpected response")
+                main.log.error( repr(response) )
+                return main.FALSE
+
+
+        except pexpect.EOF:
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":    " + self.handle.before)
+            main.cleanup()
+            main.exit()
+        except:
+            main.log.info(self.name+" ::::::")
+            main.log.error( traceback.print_exc())
+            main.log.info(self.name+" ::::::")
+            main.cleanup()
+            main.exit()
 
     #***********************************
+    def getDevicePortsEnabledCount(self,dpid):
+        '''
+        Get the count of all enabled ports on a particular device/switch
+        '''
+        try:
+            dpid = str(dpid)
+            self.handle.sendline("")
+            self.handle.expect("onos>")
+
+            self.handle.sendline("onos:ports -e "+dpid+" | wc -l")
+            i = self.handle.expect([
+                "No such device",
+                "onos>"])
+            
+            #self.handle.sendline("")
+            #self.handle.expect("onos>")
+
+            output = self.handle.before
+
+            if i == 0:
+                main.log.error("Error in getting ports")
+                return (output, "Error")
+            else:
+                result = output
+                return result
+        
+        except pexpect.EOF:
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":    " + self.handle.before)
+            main.cleanup()
+            main.exit()
+        except:
+            main.log.info(self.name+" ::::::")
+            main.log.error( traceback.print_exc())
+            main.log.info(self.name+" ::::::")
+            main.cleanup()
+            main.exit()
+
+    def getDeviceLinksActiveCount(self,dpid):
+        '''
+        Get the count of all enabled ports on a particular device/switch
+        '''
+        try:
+            dpid = str(dpid)
+            self.handle.sendline("")
+            self.handle.expect("onos>")
+
+            self.handle.sendline("onos:links "+dpid+" | grep ACTIVE | wc -l")
+            i = self.handle.expect([
+                "No such device",
+                "onos>"])
+
+            output = self.handle.before
+
+            if i == 0:
+                main.log.error("Error in getting ports")
+                return (output, "Error")
+            else:
+                result = output
+                return result
+        
+        except pexpect.EOF:
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":    " + self.handle.before)
+            main.cleanup()
+            main.exit()
+        except:
+            main.log.info(self.name+" ::::::")
+            main.log.error( traceback.print_exc())
+            main.log.info(self.name+" ::::::")
+            main.cleanup()
+            main.exit()
+
+    def getAllIntentIds(self):
+        '''
+        Return a list of all Intent IDs
+        '''
+        try:
+            self.handle.sendline("")
+            self.handle.expect("onos>")
+
+            self.handle.sendline("onos:intents | grep id=")
+            i = self.handle.expect([
+                "Error",
+                "onos>"])
+
+            output = self.handle.before
+
+            if i == 0:
+                main.log.error("Error in getting ports")
+                return (output, "Error")
+            else:
+                result = output
+                return result
+        
+        except pexpect.EOF:
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":    " + self.handle.before)
+            main.cleanup()
+            main.exit()
+        except:
+            main.log.info(self.name+" ::::::")
+            main.log.error( traceback.print_exc())
+            main.log.info(self.name+" ::::::")
+            main.cleanup()
+            main.exit()
diff --git a/TestON/drivers/common/cli/onosdriver.py b/TestON/drivers/common/cli/onosdriver.py
index 418554d..c8713e5 100644
--- a/TestON/drivers/common/cli/onosdriver.py
+++ b/TestON/drivers/common/cli/onosdriver.py
@@ -20,10 +20,8 @@
 import sys
 import time
 import pexpect
-import re
 import traceback
 import os.path
-import pydoc
 sys.path.append("../")
 from drivers.common.clidriver import CLI
 
@@ -224,12 +222,12 @@
     def git_pull(self, comp1=""):
         '''
         Assumes that "git pull" works without login
-        
+
         This function will perform a git pull on the ONOS instance.
         If used as git_pull("NODE") it will do git pull + NODE. This is
         for the purpose of pulling from other nodes if necessary.
 
-        Otherwise, this function will perform a git pull in the 
+        Otherwise, this function will perform a git pull in the
         ONOS repository. If it has any problems, it will return main.ERROR
         If it successfully does a git_pull, it will return a 1 (main.TRUE)
         If it has no updates, it will return 3.
@@ -244,14 +242,13 @@
                 self.handle.sendline("git pull")
             else:
                 self.handle.sendline("git pull " + comp1)
-           
-            uptodate = 0
+
             i=self.handle.expect(['fatal',
                 'Username\sfor\s(.*):\s',
                 '\sfile(s*) changed,\s',
                 'Already up-to-date',
                 'Aborting',
-                'You\sare\snot\scurrently\son\sa\sbranch', 
+                'You\sare\snot\scurrently\son\sa\sbranch',
                 'You\sasked\sme\sto\spull\swithout\stelling\sme\swhich\sbranch\syou',
                 'Pull\sis\snot\spossible\sbecause\syou\shave\sunmerged\sfiles',
                 pexpect.TIMEOUT],
@@ -456,8 +453,6 @@
         #Create the cell file in the directory for writing (w+)
         cell_file = open(temp_directory+file_name , 'w+')
        
-        comment = ""
-        comment_string = "#"+ comment
         #Feature string is hardcoded environment variables
         #That you may wish to use by default on startup.
         #Note that you  may not want certain features listed
@@ -625,8 +620,8 @@
 
             handle_before = self.handle.before
             print "handle_before = ", self.handle.before
-            handle_after = str(self.handle.after)
-            
+            #handle_after = str(self.handle.after)
+
             #self.handle.sendline("")
             #self.handle.expect("\$")
             #handle_more = str(self.handle.before)
@@ -1072,21 +1067,21 @@
                 if not line.startswith("time="):
                     continue
                 #else
-                print line
+                #print line
                 for var in line.split(","):
                     #print "'"+var+"'"
                     #print "'"+var.strip()+"'"
                     key, value = var.strip().split("=")
                     topology[key] = value
-            print "topology = ", topology
-            devices = topology.get('devices', False)
-            print "devices = ", devices
-            links = topology.get('links', False)
-            print "links = ", links
-            clusters = topology.get('clusters', False)
-            print "clusters = ", clusters
-            paths = topology.get('paths', False)
-            print "paths = ", paths
+            #print "topology = ", topology
+            #devices = topology.get('devices', False)
+            #print "devices = ", devices
+            #links = topology.get('links', False)
+            #print "links = ", links
+            #SCCs = topology.get('SCC(s)', False)
+            #print "SCCs = ", SCCs
+            #paths = topology.get('paths', False)
+            #print "paths = ", paths
 
             return topology
         except pexpect.EOF:
@@ -1339,3 +1334,61 @@
             main.log.error( traceback.print_exc())
             main.log.info(self.name+" ::::::")
 
+    def check_logs(self, onos_ip):
+        '''
+        runs onos-check-logs on the given onos node
+        returns the response
+        '''
+        try:
+            cmd = "onos-check-logs " + str(onos_ip)
+            self.handle.sendline(cmd)
+            self.handle.expect(cmd)
+            self.handle.expect("\$")
+            response = self.handle.before
+            return response
+        except pexpect.EOF:
+            main.log.error("Lost ssh connection")
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":    " + self.handle.before)
+        except:
+            main.log.error("Some error in check_logs:")
+            main.log.info(self.name+" ::::::")
+            main.log.error( traceback.print_exc())
+            main.log.info(self.name+" ::::::")
+
+    def onos_status(self, node=""):
+        '''
+        Calls onos command: 'onos-service [<node-ip>] status'
+        '''
+
+        try:
+            self.handle.sendline("")
+            self.handle.expect("\$")
+            self.handle.sendline("onos-service "+str(node)+
+                " status")
+            i = self.handle.expect([
+                "start/running",
+                "stop/waiting",
+                pexpect.TIMEOUT],timeout=120)
+
+            if i == 0:
+                main.log.info("ONOS is running")
+                return main.TRUE
+            elif i == 1:
+                main.log.info("ONOS is stopped")
+                return main.FALSE
+            else:
+                main.log.error("ONOS service failed to check the status")
+                main.cleanup()
+                main.exit()
+        except pexpect.EOF:
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":    " + self.handle.before)
+            main.cleanup()
+            main.exit()
+        except:
+            main.log.info(self.name+" ::::::")
+            main.log.error( traceback.print_exc())
+            main.log.info(self.name+" ::::::")
+            main.cleanup()
+            main.exit()
diff --git a/TestON/drivers/common/clidriver.py b/TestON/drivers/common/clidriver.py
index 00d00ed..878839e 100644
--- a/TestON/drivers/common/clidriver.py
+++ b/TestON/drivers/common/clidriver.py
@@ -48,7 +48,7 @@
         ssh_newkey = 'Are you sure you want to continue connecting'
         refused = "ssh: connect to host "+self.ip_address+" port 22: Connection refused"
         if self.port:
-            self.handle =pexpect.spawn('ssh -p '+self.port+' '+self.user_name+'@'+self.ip_address,maxread=50000)
+            self.handle =pexpect.spawn('ssh -p '+self.port+' '+self.user_name+'@'+self.ip_address, env = {"TERM": "vt100"} , maxread=50000)
         else :
             self.handle =pexpect.spawn('ssh -X '+self.user_name+'@'+self.ip_address,maxread=1000000,timeout=60)
 
@@ -190,7 +190,9 @@
         '''
         ssh_newkey = 'Are you sure you want to continue connecting'
         refused = "ssh: connect to host "+ip_address+" port 22: Connection refused"
-        self.handle =pexpect.spawn('scp '+user_name+'@'+ip_address+':'+filepath+' '+dst_path)
+        cmd = 'scp '+str(user_name)+'@'+str(ip_address)+':'+str(filepath)+' '+str(dst_path)
+        main.log.info("Sending: " + cmd )
+        self.handle =pexpect.spawn( cmd )
         i=self.handle.expect([ssh_newkey,'password:',pexpect.EOF,pexpect.TIMEOUT,refused],120)
         
         if i==0:    
@@ -212,7 +214,9 @@
             main.log.error("ssh: connect to host "+ip_address+" port 22: Connection refused")
             return main.FALSE
 
-        self.handle.sendline("\r")
+        self.handle.sendline("")
+        self.handle.expect("$")
+        print self.handle.before
         
         return self.handle
     
diff --git a/TestON/tests/FuncNext/FuncNext.params b/TestON/tests/FuncNext/FuncNext.params
deleted file mode 100755
index 34d8a56..0000000
--- a/TestON/tests/FuncNext/FuncNext.params
+++ /dev/null
@@ -1,43 +0,0 @@
-<PARAMS>
-    
-    <testcases>1,4,5,7,3</testcases>
-
-    #Environment variables
-    <ENV>
-        <cellName>driver_test</cellName>
-    </ENV>
-
-    <CTRL>
-        <ip1>10.128.60.11</ip1>
-        <port1>6633</port1>
-    </CTRL>
-
-    <PING>
-        <source1>h8</source1>
-        <source2>h9</source2>
-        <source3>h10</source3>
-        <source4>h11</source4>
-        <source5>h12</source5>
-        <source6>h13</source6>
-        <source7>h14</source7>
-        <source8>h15</source8>
-        <source9>h16</source9>
-        <source10>h17</source10>
-        <target1>10.0.0.18</target1>
-        <target2>10.0.0.19</target2>
-        <target3>10.0.0.20</target3>
-        <target4>10.0.0.21</target4>
-        <target5>10.0.0.22</target5>
-        <target6>10.0.0.23</target6>
-        <target7>10.0.0.24</target7>
-        <target8>10.0.0.25</target8>
-        <target9>10.0.0.26</target9>
-        <target10>10.0.0.27</target10>
-    </PING>
-
-    <timers>
-        <LinkDiscovery>5</LinkDiscovery>
-        <SwitchDiscovery>31</SwitchDiscovery>
-    </timers>
-
-</PARAMS>
diff --git a/TestON/tests/FuncNext/FuncNext.py b/TestON/tests/FuncNext/FuncNext.py
deleted file mode 100755
index c0b96d2..0000000
--- a/TestON/tests/FuncNext/FuncNext.py
+++ /dev/null
@@ -1,608 +0,0 @@
-
-#Testing the basic functionality of ONOS Next
-#For sanity and driver functionality excercises only.
-
-import time
-import sys
-import os
-import re
-import time
-import json
-
-time.sleep(1)
-class FuncNext:
-    def __init__(self):
-        self.default = ''
-
-    def CASE1(self, main):
-        '''
-        Startup sequence:
-        git pull
-        mvn clean install
-        onos-package
-        cell <name>
-        onos-verify-cell
-        onos-install -f
-        onos-wait-for-start
-        '''
-        
-        cell_name = main.params['ENV']['cellName']
-        ONOS1_ip = main.params['CTRL']['ip1']
-        ONOS1_port = main.params['CTRL']['port1']
-        
-        main.case("Setting up test environment")
-        
-        main.step("Git checkout and pull master and get version")
-        main.ONOSbench.git_checkout("master")
-        git_pull_result = main.ONOSbench.git_pull()
-        print "git_pull_result = ", git_pull_result
-        version_result = main.ONOSbench.get_version()
-
-        if git_pull_result == 2:
-            main.step("Using mvn clean & install")
-            clean_install_result = main.ONOSbench.clean_install()
-            #clean_install_result = main.TRUE
-
-        main.step("Applying cell variable to environment")
-        cell_result1 = main.ONOSbench.set_cell(cell_name)
-        verify_result = main.ONOSbench.verify_cell()
-        cell_result2 = main.ONOS2.set_cell(cell_name)
-        #verify_result = main.ONOS2.verify_cell()
-        main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
-        
-        cell_result = cell_result1 and cell_result2
-
-        main.step("Creating ONOS package")
-        package_result = main.ONOSbench.onos_package()
-
-        #main.step("Creating a cell")
-        #cell_create_result = main.ONOSbench.create_cell_file(**************)
-
-        main.step("Installing ONOS package")
-        onos_install_result = main.ONOSbench.onos_install()
-        onos1_isup = main.ONOSbench.isup()
-   
-        main.step("Starting ONOS service")
-        start_result = main.ONOSbench.onos_start(ONOS1_ip)
-
-        case1_result = (package_result and\
-                cell_result and verify_result and onos_install_result and\
-                onos1_isup and start_result )
-        utilities.assert_equals(expect=main.TRUE, actual=case1_result,
-                onpass="Test startup successful",
-                onfail="Test startup NOT successful")
-
-    def CASE11(self, main):
-        '''
-        Cleanup sequence:
-        onos-service <node_ip> stop
-        onos-uninstall
-
-        TODO: Define rest of cleanup
-        
-        '''
-
-        ONOS1_ip = main.params['CTRL']['ip1']
-
-        main.case("Cleaning up test environment")
-
-        main.step("Testing ONOS kill function")
-        kill_result = main.ONOSbench.onos_kill(ONOS1_ip)
-
-        main.step("Stopping ONOS service")
-        stop_result = main.ONOSbench.onos_stop(ONOS1_ip)
-
-        main.step("Uninstalling ONOS service") 
-        uninstall_result = main.ONOSbench.onos_uninstall()
-
-    def CASE3(self, main):
-        '''
-        Test 'onos' command and its functionality in driver
-        '''
-        
-        ONOS1_ip = main.params['CTRL']['ip1']
-
-        main.case("Testing 'onos' command")
-
-        main.step("Sending command 'onos -w <onos-ip> system:name'")
-        cmdstr1 = "system:name"
-        cmd_result1 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr1) 
-        main.log.info("onos command returned: "+cmd_result1)
-
-        main.step("Sending command 'onos -w <onos-ip> onos:topology'")
-        cmdstr2 = "onos:topology"
-        cmd_result2 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr2)
-        main.log.info("onos command returned: "+cmd_result2)
-
-
-
-    def CASE4(self, main):
-        import re
-        import time
-        main.case("Pingall Test")
-        main.step("Assigning switches to controllers")
-        for i in range(1,29):
-            if i ==1:
-                main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
-            elif i>=2 and i<5:
-                main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
-            elif i>=5 and i<8:
-                main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
-            elif i>=8 and i<18:
-                main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
-            elif i>=18 and i<28:
-                main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
-            else:
-                main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
-        Switch_Mastership = main.TRUE
-        for i in range (1,29):
-            if i==1:
-                response = main.Mininet1.get_sw_controller("s"+str(i))
-                print("Response is " + str(response))
-                if re.search("tcp:"+ONOS1_ip,response):
-                    Switch_Mastership = Switch_Mastership and main.TRUE
-                else:
-                    Switch_Mastership = main.FALSE
-            elif i>=2 and i<5:
-                response = main.Mininet1.get_sw_controller("s"+str(i))
-                print("Response is " + str(response))
-                if re.search("tcp:"+ONOS1_ip,response):
-                    Switch_Mastership = Switch_Mastership and main.TRUE
-                else:
-                    Switch_Mastership = main.FALSE
-            elif i>=5 and i<8:
-                response = main.Mininet1.get_sw_controller("s"+str(i))
-                print("Response is " + str(response))
-                if re.search("tcp:"+ONOS1_ip,response):
-                    Switch_Mastership = Switch_Mastership and main.TRUE
-                else:
-                    Switch_Mastership = main.FALSE
-            elif i>=8 and i<18:
-                response = main.Mininet1.get_sw_controller("s"+str(i))
-                print("Response is " + str(response))
-                if re.search("tcp:"+ONOS1_ip,response):
-                    Switch_Mastership = Switch_Mastership and main.TRUE
-                else:
-                    Switch_Mastership = main.FALSE
-            elif i>=18 and i<28:
-                response = main.Mininet1.get_sw_controller("s"+str(i))
-                print("Response is " + str(response))
-                if re.search("tcp:"+ONOS1_ip,response):
-                    Switch_Mastership = Switch_Mastership and main.TRUE
-                else:
-                    Switch_Mastership = main.FALSE
-            else:
-                response = main.Mininet1.get_sw_controller("s"+str(i))
-                print("Response is" + str(response))
-                if re.search("tcp:" +ONOS1_ip,response):
-                    Switch_Mastership = Switch_Mastership and main.TRUE
-                else:
-                    Switch_Mastership = main.FALSE
-
-        if Switch_Mastership == main.TRUE:
-            main.log.report("MasterControllers assigned correctly")
-        utilities.assert_equals(expect = main.TRUE,actual=Switch_Mastership,
-                onpass="MasterControllers assigned correctly")
-        '''
-        for i in range (1,29):
-            main.Mininet1.assign_sw_controller(sw=str(i),count=5,
-                    ip1=ONOS1_ip,port1=ONOS1_port,
-                    ip2=ONOS2_ip,port2=ONOS2_port,
-                    ip3=ONOS3_ip,port3=ONOS3_port,
-                    ip4=ONOS4_ip,port4=ONOS4_port,
-                    ip5=ONOS5_ip,port5=ONOS5_port)
-        '''
-        #REACTIVE FWD test
-
-        main.step("Get list of hosts from Mininet")
-        host_list = main.Mininet1.get_hosts()
-        main.log.info(host_list)
-
-        main.step("Get host list in ONOS format")
-        host_onos_list = main.ONOS2.get_hosts_id(host_list)
-        main.log.info(host_onos_list)
-        #time.sleep(5)
-
-        #We must use ping from hosts we want to add intents from 
-        #to make the hosts talk
-        #main.Mininet2.handle.sendline("\r")
-        #main.Mininet2.handle.sendline("h4 ping 10.1.1.1 -c 1 -W 1")
-        #time.sleep(3)
-        #main.Mininet2.handle.sendline("h5 ping 10.1.1.1 -c 1 -W 1")
-        #time.sleep(5)
-        
-        main.step("Pingall")
-        ping_result = main.FALSE
-        while ping_result == main.FALSE:
-            time1 = time.time()
-            ping_result = main.Mininet1.pingall()
-            time2 = time.time()
-            print "Time for pingall: %2f seconds" % (time2 - time1)
-      
-        #Start onos cli again because u might have dropped out of onos prompt to the shell prompt
-        #if there was no activity
-        main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
-
-        main.step("Get hosts")
-        main.ONOS2.handle.sendline("hosts")
-        main.ONOS2.handle.expect("onos>")
-        hosts = main.ONOS2.handle.before
-        main.log.info(hosts)
-
-        main.step("Get all devices id")
-        devices_id_list = main.ONOS2.get_all_devices_id()
-        main.log.info(devices_id_list)
-        
-        #ONOS displays the hosts in hex format unlike mininet which does in decimal format
-        #So take care while adding intents
-        
-        main.step("Add host-to-host intents for mininet hosts h8 and h18 or ONOS hosts h8 and h12")
-        hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1")
-        hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1")
-        hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1")
-        hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1")
-        hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1")
-        hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1")
-        hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1")
-        hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1")
-        hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1") 
-        hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1")
-
- 
-        
-        print "_____________________________________________________________________________________"
-        ''' 
-        main.step("Add point-to-point intents for mininet hosts h8 and h18 or ONOS hosts h8 and h12")
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003008", 1, "of:0000000000006018", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-       
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006018", 1, "of:0000000000003008", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-       
-        main.step("Add point-to-point intents for mininet hosts h9 and h19 or ONOS hosts h9 and h13")
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003009", 1, "of:0000000000006019", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-       
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006019", 1, "of:0000000000003009", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-        
-        main.step("Add point-to-point intents for mininet hosts h10 and h20 or ONOS hosts hA and h14")
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003010", 1, "of:0000000000006020", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-       
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006020", 1, "of:0000000000003010", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-            
-        main.step("Add point-to-point intents for mininet hosts h11 and h21 or ONOS hosts hB and h15")
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003011", 1, "of:0000000000006021", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-       
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006021", 1, "of:0000000000003011", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-            
-        main.step("Add point-to-point intents for mininet hosts h12 and h22 or ONOS hosts hC and h16")
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003012", 1, "of:0000000000006022", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-       
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006022", 1, "of:0000000000003012", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-            
-        main.step("Add point-to-point intents for mininet hosts h13 and h23 or ONOS hosts hD and h17")
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003013", 1, "of:0000000000006023", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-       
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006023", 1, "of:0000000000003013", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-            
-        main.step("Add point-to-point intents for mininet hosts h14 and h24 or ONOS hosts hE and h18")
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003014", 1, "of:0000000000006024", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-       
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006024", 1, "of:0000000000003014", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-            
-        main.step("Add point-to-point intents for mininet hosts h15 and h25 or ONOS hosts hF and h19")
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003015", 1, "of:0000000000006025", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-       
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006025", 1, "of:0000000000003015", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-            
-        main.step("Add point-to-point intents for mininet hosts h16 and h26 or ONOS hosts h10 and h1A")
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003016", 1, "of:0000000000006026", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-       
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006026", 1, "of:0000000000003016", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-        
-        main.step("Add point-to-point intents for mininet hosts h17 and h27 or ONOS hosts h11 and h1B")
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003017", 1, "of:0000000000006027", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-       
-        ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006027", 1, "of:0000000000003017", 1)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOS2.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-
-        print("_______________________________________________________________________________________")
-        '''
-
-        #Unistall onos-app-fwd app to disable reactive forwarding
-        appUninstall_result = main.ONOS2.feature_uninstall("onos-app-fwd")
-        main.log.info("onos-app-fwd uninstalled")
-
-        #After reactive forwarding is disabled, the reactive flows on switches timeout in 10-15s
-        #So sleep for 15s
-        time.sleep(15)
-        
-        flowHandle = main.ONOS2.flows()
-        print "flowHandle = ", flowHandle
-
-        count = 1
-        i = 8
-        Ping_Result = main.TRUE
-        #while i<10:
-        while i <18 :
-            main.log.info("\n\nh"+str(i)+" is Pinging h" + str(i+10))
-            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+10))
-            if ping == main.FALSE and count <5:
-                count+=1
-                i = 8
-                Ping_Result = main.FALSE
-                main.log.report("Ping between h" + str(i) + " and h" + str(i+10) + " failed. Making attempt number "+str(count) + " in 2 seconds")
-                time.sleep(2)
-            elif ping==main.FALSE:
-                main.log.report("All ping attempts have failed")
-                i=19
-                Ping_Result = main.FALSE
-            elif ping==main.TRUE:
-                main.log.info("Ping test passed!")
-                i+=1
-                Ping_Result = main.TRUE
-            else:
-                main.log.info("Unknown error")
-                Ping_Result = main.ERROR
-        if Ping_Result==main.FALSE:
-            main.log.report("Intents have not ben installed correctly. Cleaning up")
-            #main.cleanup()
-            #main.exit()
-        if Ping_Result==main.TRUE:
-            main.log.report("Intents have been installed correctly")
-            
-        case4_result = Switch_Mastership and Ping_Result
-        utilities.assert_equals(expect=main.TRUE, actual=case4_result,
-                onpass="Pingall Test successful",
-                onfail="Pingall Test NOT successful")
-
-    def CASE5(self,main) :
-        import json
-        from subprocess import Popen, PIPE
-        from sts.topology.teston_topology import TestONTopology # assumes that sts is already in you PYTHONPATH
-        #main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
-        deviceResult = main.ONOS2.devices()
-        linksResult = main.ONOS2.links()
-        portsResult = main.ONOS2.ports()
-        print "**************"
-        main.step("Start continuous pings")
-        main.Mininet2.pingLong(src=main.params['PING']['source1'],
-                            target=main.params['PING']['target1'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source2'],
-                            target=main.params['PING']['target2'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source3'],
-                            target=main.params['PING']['target3'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source4'],
-                            target=main.params['PING']['target4'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source5'],
-                            target=main.params['PING']['target5'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source6'],
-                            target=main.params['PING']['target6'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source7'],
-                            target=main.params['PING']['target7'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source8'],
-                            target=main.params['PING']['target8'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source9'],
-                            target=main.params['PING']['target9'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source10'],
-                            target=main.params['PING']['target10'],pingTime=500)
-
-        main.step("Create TestONTopology object")
-        global ctrls
-        ctrls = []
-        count = 1
-        while True:
-            temp = ()
-            if ('ip' + str(count)) in main.params['CTRL']:
-                temp = temp + (getattr(main,('ONOS' + str(count))),)
-                temp = temp + ("ONOS"+str(count),)
-                temp = temp + (main.params['CTRL']['ip'+str(count)],)
-                temp = temp + (eval(main.params['CTRL']['port'+str(count)]),)
-                ctrls.append(temp)
-                count = count + 1
-            else:
-                break
-        global MNTopo
-        Topo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
-        MNTopo = Topo
-
-        Topology_Check = main.TRUE
-        main.step("Compare ONOS Topology to MN Topology")
-        devices_json = main.ONOS2.devices()
-        links_json = main.ONOS2.links()
-        ports_json = main.ONOS2.ports()
-        print "devices_json= ", devices_json
-        
-        result1 = main.Mininet1.compare_switches(MNTopo, json.loads(devices_json))
-        print "***********************"
-        result2 = main.Mininet1.compare_links(MNTopo, json.loads(links_json))
-        print "***********************"
-        result3 = main.Mininet1.compare_ports(MNTopo, json.loads(ports_json))
-            
-        result = result1 and result2 and result3
-        print "***********************"
-        if result == main.TRUE:
-            main.log.report("ONOS"+ " Topology matches MN Topology")
-        utilities.assert_equals(expect=main.TRUE,actual=result,
-            onpass="ONOS" + " Topology matches MN Topology",
-            onfail="ONOS" + " Topology does not match MN Topology")
-        Topology_Check = Topology_Check and result
-        utilities.assert_equals(expect=main.TRUE,actual=Topology_Check,
-            onpass="Topology checks passed", onfail="Topology checks failed")
-    
-
-    def CASE7 (self,main):
-       
-        ONOS1_ip = main.params['CTRL']['ip1']
-
-        link_sleep = int(main.params['timers']['LinkDiscovery'])
-
-        main.log.report("Killing a link to ensure that link discovery is consistent")
-        main.case("Killing a link to Ensure that Link Discovery is Working Properly")
-        main.step("Start continuous pings")
-       
-        main.Mininet2.pingLong(src=main.params['PING']['source1'],
-                            target=main.params['PING']['target1'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source2'],
-                            target=main.params['PING']['target2'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source3'],
-                            target=main.params['PING']['target3'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source4'],
-                            target=main.params['PING']['target4'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source5'],
-                            target=main.params['PING']['target5'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source6'],
-                            target=main.params['PING']['target6'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source7'],
-                            target=main.params['PING']['target7'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source8'],
-                            target=main.params['PING']['target8'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source9'],
-                            target=main.params['PING']['target9'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source10'],
-                            target=main.params['PING']['target10'],pingTime=500)
-
-
-        main.step("Determine the current number of switches and links")
-        topology_output = main.ONOS2.topology()
-        topology_result = main.ONOS1.get_topology(topology_output)
-        activeSwitches = topology_result['devices']
-        links = topology_result['links']
-        print "activeSwitches = ", type(activeSwitches)
-        print "links = ", type(links)
-        main.log.info("Currently there are %s switches and %s links"  %(str(activeSwitches), str(links)))
-
-        main.step("Kill Link between s3 and s28")
-        main.Mininet1.link(END1="s3",END2="s28",OPTION="down")
-        time.sleep(link_sleep)
-        topology_output = main.ONOS2.topology()
-        Link_Down = main.ONOS1.check_status(topology_output,activeSwitches,str(int(links)-2))
-        if Link_Down == main.TRUE:
-            main.log.report("Link Down discovered properly")
-        utilities.assert_equals(expect=main.TRUE,actual=Link_Down,
-                onpass="Link Down discovered properly",
-                onfail="Link down was not discovered in "+ str(link_sleep) + " seconds")
-        
-        main.step("Bring link between s3 and s28 back up")
-        Link_Up = main.Mininet1.link(END1="s3",END2="s28",OPTION="up")
-        time.sleep(link_sleep)
-        topology_output = main.ONOS2.topology()
-        Link_Up = main.ONOS1.check_status(topology_output,activeSwitches,str(links))
-        if Link_Up == main.TRUE:
-            main.log.report("Link up discovered properly")
-        utilities.assert_equals(expect=main.TRUE,actual=Link_Up,
-                onpass="Link up discovered properly",
-                onfail="Link up was not discovered in "+ str(link_sleep) + " seconds")
-
-
-
-
-        main.step("Compare ONOS Topology to MN Topology")
-        Topo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
-        MNTopo = Topo
-        Topology_Check = main.TRUE
-        devices_json = main.ONOS2.devices()
-        links_json = main.ONOS2.links()
-        ports_json = main.ONOS2.ports()
-        print "devices_json= ", devices_json
-        
-        result1 = main.Mininet1.compare_switches(MNTopo, json.loads(devices_json))
-        print "***********************"
-        result2 = main.Mininet1.compare_links(MNTopo, json.loads(links_json))
-        print "***********************"
-        result3 = main.Mininet1.compare_ports(MNTopo, json.loads(ports_json))
-            
-        result = result1 and result2 and result3
-        print "***********************"
-        if result == main.TRUE:
-            main.log.report("ONOS"+ " Topology matches MN Topology")
-        utilities.assert_equals(expect=main.TRUE,actual=result,
-            onpass="ONOS" + " Topology matches MN Topology",
-            onfail="ONOS" + " Topology does not match MN Topology")
-        Topology_Check = Topology_Check and result
-        utilities.assert_equals(expect=main.TRUE,actual=Topology_Check,
-            onpass="Topology checks passed", onfail="Topology checks failed")
-    
-        result = Link_Down and Link_Up and Topology_Check
-        utilities.assert_equals(expect=main.TRUE,actual=result,
-                onpass="Link failure is discovered correctly",
-                onfail="Link Discovery failed")
-
-
-
diff --git a/TestON/tests/FuncNext/FuncNext.topo b/TestON/tests/FuncNext/FuncNext.topo
deleted file mode 100755
index 444c605..0000000
--- a/TestON/tests/FuncNext/FuncNext.topo
+++ /dev/null
@@ -1,61 +0,0 @@
-<TOPOLOGY>
-    <COMPONENT>
-
-        <ONOSbench>
-            <host>10.128.60.10</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>OnosDriver</type>
-            <connect_order>1</connect_order>
-            <COMPONENTS> </COMPONENTS>
-        </ONOSbench>
-
-        <ONOS1>
-            <host>10.128.60.10</host>
-            <user>sdn</user>
-            <password>sdn</password>
-            <type>OnosDriver</type>
-            <connect_order>2</connect_order>
-            <COMPONENTS> </COMPONENTS>
-        </ONOS1>
-
-        <ONOS2>
-            <host>10.128.60.10</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>OnosCliDriver</type>
-            <connect_order>3</connect_order>
-            <COMPONENTS> </COMPONENTS>
-        </ONOS2>
-
-        <Mininet1>
-            <host>10.128.9.10</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>MininetCliDriver</type>
-            <connect_order>4</connect_order>
-            <COMPONENTS>
-                #Specify the Option for mininet
-                <arg1> --custom ~/mininet/custom/topo-HA.py </arg1>
-                <arg2> --topo mytopo </arg2>
-                <arg3> --switch ovs,protocols=OpenFlow10 </arg3>
-                <controller> remote </controller>
-            </COMPONENTS>
-        </Mininet1>
-
-        <Mininet2>
-            <host>10.128.9.10</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>RemoteMininetDriver</type>
-            <connect_order>5</connect_order>
-            <COMPONENTS>
-                #Specify the Option for mininet
-                <arg1> --custom ~/mininet/custom/topo-HA.py </arg1>
-                <arg2> --topo mytopo </arg2>
-                <arg3> --switch ovs,protocols=OpenFlow10 </arg3>
-                <controller> remote </controller>
-            </COMPONENTS>
-        </Mininet2>
-    </COMPONENT>
-</TOPOLOGY>
diff --git a/TestON/tests/FuncNext/__init__.py b/TestON/tests/FuncNext/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/TestON/tests/FuncNext/__init__.py
+++ /dev/null
diff --git a/TestON/tests/HATestClusterRestart/HATestClusterRestart.params b/TestON/tests/HATestClusterRestart/HATestClusterRestart.params
index 0a8bd57..38a9b02 100644
--- a/TestON/tests/HATestClusterRestart/HATestClusterRestart.params
+++ b/TestON/tests/HATestClusterRestart/HATestClusterRestart.params
@@ -1,9 +1,10 @@
 <PARAMS>
-    <testcases>1,2,8,3,4,5,[6],7,8,4,9,8,4,10,8,4,11,8,4,12,8,4,13</testcases>
+    <testcases>1,2,8,3,4,5,14,[6],8,3,7,4,15,9,8,4,10,8,4,11,8,4,12,8,4,13</testcases>
     <ENV>
     <cellName>HA</cellName>
     </ENV>
     <Git>False</Git>
+    <num_controllers> 7 </num_controllers>
 
     <CTRL>
         <ip1>10.128.30.11</ip1>
@@ -28,7 +29,7 @@
         <port7>6633</port7>
     </CTRL>
     <TESTONUSER>admin</TESTONUSER>
-    <TESTONIP>10.128.30.10</TESTONIP>
+    <TESTONIP>10.128.30.9</TESTONIP>
     <PING>
         <source1>h8</source1>
         <source2>h9</source2>
@@ -52,8 +53,8 @@
         <target10>10.0.0.27</target10>
     </PING>
     <timers>
-        <LinkDiscovery>2</LinkDiscovery>
-        <SwitchDiscovery>2</SwitchDiscovery>
+        <LinkDiscovery>.2</LinkDiscovery>
+        <SwitchDiscovery>.2</SwitchDiscovery>
     </timers>
     <MNtcpdump>
         <intf>eth0</intf>
diff --git a/TestON/tests/HATestClusterRestart/HATestClusterRestart.py b/TestON/tests/HATestClusterRestart/HATestClusterRestart.py
index 47dc744..b9a07b9 100644
--- a/TestON/tests/HATestClusterRestart/HATestClusterRestart.py
+++ b/TestON/tests/HATestClusterRestart/HATestClusterRestart.py
@@ -16,6 +16,8 @@
 CASE11: Switch down
 CASE12: Switch up
 CASE13: Clean up
+CASE14: start election app on all onos nodes
+CASE15: Check that Leadership Election is still functional
 '''
 class HATestClusterRestart:
 
@@ -61,6 +63,7 @@
         global ONOS6_port
         global ONOS7_ip
         global ONOS7_port
+        global num_controllers
 
         ONOS1_ip = main.params['CTRL']['ip1']
         ONOS1_port = main.params['CTRL']['port1']
@@ -76,13 +79,14 @@
         ONOS6_port = main.params['CTRL']['port6']
         ONOS7_ip = main.params['CTRL']['ip7']
         ONOS7_port = main.params['CTRL']['port7']
+        num_controllers = int(main.params['num_controllers'])
 
 
         main.step("Applying cell variable to environment")
         cell_result = main.ONOSbench.set_cell(cell_name)
         verify_result = main.ONOSbench.verify_cell()
 
-        #FIXME:this is short term fix 
+        #FIXME:this is short term fix
         main.log.report("Removing raft logs")
         main.ONOSbench.onos_remove_raft_logs()
         main.log.report("Uninstalling ONOS")
@@ -143,31 +147,33 @@
 
 
         main.step("Checking if ONOS is up yet")
-        #TODO: Refactor
-        # check bundle:list?
-        onos1_isup = main.ONOSbench.isup(ONOS1_ip)
-        if not onos1_isup:
-            main.log.report("ONOS1 didn't start!")
-        onos2_isup = main.ONOSbench.isup(ONOS2_ip)
-        if not onos2_isup:
-            main.log.report("ONOS2 didn't start!")
-        onos3_isup = main.ONOSbench.isup(ONOS3_ip)
-        if not onos3_isup:
-            main.log.report("ONOS3 didn't start!")
-        onos4_isup = main.ONOSbench.isup(ONOS4_ip)
-        if not onos4_isup:
-            main.log.report("ONOS4 didn't start!")
-        onos5_isup = main.ONOSbench.isup(ONOS5_ip)
-        if not onos5_isup:
-            main.log.report("ONOS5 didn't start!")
-        onos6_isup = main.ONOSbench.isup(ONOS6_ip)
-        if not onos6_isup:
-            main.log.report("ONOS6 didn't start!")
-        onos7_isup = main.ONOSbench.isup(ONOS7_ip)
-        if not onos7_isup:
-            main.log.report("ONOS7 didn't start!")
-        onos_isup_result = onos1_isup and onos2_isup and onos3_isup\
-                and onos4_isup and onos5_isup and onos6_isup and onos7_isup
+        #TODO check bundle:list?
+        for i in range(2):
+            onos1_isup = main.ONOSbench.isup(ONOS1_ip)
+            if not onos1_isup:
+                main.log.report("ONOS1 didn't start!")
+            onos2_isup = main.ONOSbench.isup(ONOS2_ip)
+            if not onos2_isup:
+                main.log.report("ONOS2 didn't start!")
+            onos3_isup = main.ONOSbench.isup(ONOS3_ip)
+            if not onos3_isup:
+                main.log.report("ONOS3 didn't start!")
+            onos4_isup = main.ONOSbench.isup(ONOS4_ip)
+            if not onos4_isup:
+                main.log.report("ONOS4 didn't start!")
+            onos5_isup = main.ONOSbench.isup(ONOS5_ip)
+            if not onos5_isup:
+                main.log.report("ONOS5 didn't start!")
+            onos6_isup = main.ONOSbench.isup(ONOS6_ip)
+            if not onos6_isup:
+                main.log.report("ONOS6 didn't start!")
+            onos7_isup = main.ONOSbench.isup(ONOS7_ip)
+            if not onos7_isup:
+                main.log.report("ONOS7 didn't start!")
+            onos_isup_result = onos1_isup and onos2_isup and onos3_isup\
+                    and onos4_isup and onos5_isup and onos6_isup and onos7_isup
+            if onos_isup_result == main.TRUE:
+                break
         # TODO: if it becomes an issue, we can retry this step  a few times
 
 
@@ -197,9 +203,9 @@
                 onfail="Test startup NOT successful")
 
 
-        #if case1_result==main.FALSE:
-        #    main.cleanup()
-        #    main.exit()
+        if case1_result==main.FALSE:
+            main.cleanup()
+            main.exit()
 
     def CASE2(self,main) :
         '''
@@ -209,31 +215,12 @@
         import json
         import re
 
-
-        '''
-        ONOS1_ip = main.params['CTRL']['ip1']
-        ONOS1_port = main.params['CTRL']['port1']
-        ONOS2_ip = main.params['CTRL']['ip2']
-        ONOS2_port = main.params['CTRL']['port2']
-        ONOS3_ip = main.params['CTRL']['ip3']
-        ONOS3_port = main.params['CTRL']['port3']
-        ONOS4_ip = main.params['CTRL']['ip4']
-        ONOS4_port = main.params['CTRL']['port4']
-        ONOS5_ip = main.params['CTRL']['ip5']
-        ONOS5_port = main.params['CTRL']['port5']
-        ONOS6_ip = main.params['CTRL']['ip6']
-        ONOS6_port = main.params['CTRL']['port6']
-        ONOS7_ip = main.params['CTRL']['ip7']
-        ONOS7_port = main.params['CTRL']['port7']
-        '''
-
-
         main.log.report("Assigning switches to controllers")
         main.case("Assigning Controllers")
         main.step("Assign switches to controllers")
 
         for i in range (1,29):
-           main.Mininet1.assign_sw_controller(sw=str(i),count=7,
+           main.Mininet1.assign_sw_controller(sw=str(i),count=num_controllers,
                     ip1=ONOS1_ip,port1=ONOS1_port,
                     ip2=ONOS2_ip,port2=ONOS2_port,
                     ip3=ONOS3_ip,port3=ONOS3_port,
@@ -265,8 +252,217 @@
                 onpass="Switch mastership assigned correctly",
                 onfail="Switches not assigned correctly to controllers")
 
-        #TODO: If assign roles is working reliably then manually 
-        #   assign mastership to the controller we want
+        #Manually assign mastership to the controller we want
+        role_call = main.TRUE
+        role_check = main.TRUE
+
+        device_id = main.ONOScli1.get_device("1000")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS1_ip)
+        if ONOS1_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("2800")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS1_ip)
+        if ONOS1_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("2000")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS2_ip)
+        if ONOS2_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3000")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS2_ip)
+        if ONOS2_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("5000")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS3_ip)
+        if ONOS3_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6000")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS3_ip)
+        if ONOS3_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id =  main.ONOScli1.get_device("3004")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS4_ip)
+        if ONOS4_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3008")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3009")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3010")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3011")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3012")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3013")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3014")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3015")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3016")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3017")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6007")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS6_ip)
+        if ONOS6_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6018")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6019")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6020")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6021")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6022")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6023")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6024")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6025")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6026")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6027")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        utilities.assert_equals(expect = main.TRUE,actual=role_call,
+                onpass="Re-assigned switch mastership to designated controller",
+                onfail="Something wrong with device_role calls")
+
+        utilities.assert_equals(expect = main.TRUE,actual=role_check,
+                onpass="Switches were successfully reassigned to designated controller",
+                onfail="Switches were not successfully reassigned")
+        mastership_check = mastership_check and role_call and role_check
+        utilities.assert_equals(expect = main.TRUE,actual=mastership_check,
+                onpass="Switch mastership correctly assigned",
+                onfail="Error in (re)assigning switch mastership")
 
 
     def CASE3(self,main) :
@@ -274,6 +470,7 @@
         Assign intents
 
         """
+        #FIXME: we must reinstall intents until we have a persistant datastore!
         import time
         import json
         import re
@@ -283,6 +480,16 @@
         main.step("Discovering  Hosts( Via pingall for now)")
         #FIXME: Once we have a host discovery mechanism, use that instead
 
+        #install onos-app-fwd
+        main.log.info("Install reactive forwarding app")
+        main.ONOScli1.feature_install("onos-app-fwd")
+        main.ONOScli2.feature_install("onos-app-fwd")
+        main.ONOScli3.feature_install("onos-app-fwd")
+        main.ONOScli4.feature_install("onos-app-fwd")
+        main.ONOScli5.feature_install("onos-app-fwd")
+        main.ONOScli6.feature_install("onos-app-fwd")
+        main.ONOScli7.feature_install("onos-app-fwd")
+
         #REACTIVE FWD test
         ping_result = main.FALSE
         time1 = time.time()
@@ -299,22 +506,30 @@
         main.ONOScli5.feature_uninstall("onos-app-fwd")
         main.ONOScli6.feature_uninstall("onos-app-fwd")
         main.ONOScli7.feature_uninstall("onos-app-fwd")
+        #timeout for fwd flows
+        time.sleep(10)
 
         main.step("Add  host intents")
         #TODO:  move the host numbers to params
         import json
         intents_json= json.loads(main.ONOScli1.hosts())
-        intent_add_result = main.FALSE
+        intent_add_result = True
         for i in range(8,18):
             main.log.info("Adding host intent between h"+str(i)+" and h"+str(i+10))
             host1 =  "00:00:00:00:00:" + str(hex(i)[2:]).zfill(2).upper()
             host2 =  "00:00:00:00:00:" + str(hex(i+10)[2:]).zfill(2).upper()
-            #NOTE: get host can return None
-            #TODO: handle this
             host1_id = main.ONOScli1.get_host(host1)['id']
             host2_id = main.ONOScli1.get_host(host2)['id']
-            tmp_result = main.ONOScli1.add_host_intent(host1_id, host2_id )
-            intent_add_result = intent_add_result and tmp_result
+            #NOTE: get host can return None
+            if host1_id and host2_id:
+                tmp_result = main.ONOScli1.add_host_intent(host1_id, host2_id )
+            else:
+                main.log.error("Error, get_host() failed")
+                tmp_result = main.FALSE
+            intent_add_result = bool(intent_add_result and tmp_result)
+        utilities.assert_equals(expect=True, actual=intent_add_result,
+                onpass="Switch mastership correctly assigned",
+                onfail="Error in (re)assigning switch mastership")
         #TODO Check if intents all exist in datastore
         #NOTE: Do we need to print this once the test is working?
         #main.log.info(json.dumps(json.loads(main.ONOScli1.intents(json_format=True)),
@@ -360,6 +575,25 @@
 
         main.step("Get the Mastership of each switch from each controller")
         global mastership_state
+        mastership_state = []
+
+        #Assert that each device has a master
+        ONOS1_master_not_null = main.ONOScli1.roles_not_null()
+        ONOS2_master_not_null = main.ONOScli2.roles_not_null()
+        ONOS3_master_not_null = main.ONOScli3.roles_not_null()
+        ONOS4_master_not_null = main.ONOScli4.roles_not_null()
+        ONOS5_master_not_null = main.ONOScli5.roles_not_null()
+        ONOS6_master_not_null = main.ONOScli6.roles_not_null()
+        ONOS7_master_not_null = main.ONOScli7.roles_not_null()
+        roles_not_null = ONOS1_master_not_null and ONOS2_master_not_null and\
+                ONOS3_master_not_null and ONOS4_master_not_null and\
+                ONOS5_master_not_null and ONOS6_master_not_null and\
+                ONOS7_master_not_null
+        utilities.assert_equals(expect = main.TRUE,actual=roles_not_null,
+                onpass="Each device has a master",
+                onfail="Some devices don't have a master assigned")
+
+
         ONOS1_mastership = main.ONOScli1.roles()
         ONOS2_mastership = main.ONOScli2.roles()
         ONOS3_mastership = main.ONOScli3.roles()
@@ -416,6 +650,7 @@
 
         main.step("Get the intents from each controller")
         global intent_state
+        intent_state = []
         ONOS1_intents = main.ONOScli1.intents( json_format=True )
         ONOS2_intents = main.ONOScli2.intents( json_format=True )
         ONOS3_intents = main.ONOScli3.intents( json_format=True )
@@ -470,6 +705,7 @@
 
         main.step("Get the flows from each controller")
         global flow_state
+        flow_state = []
         ONOS1_flows = main.ONOScli1.flows( json_format=True )
         ONOS2_flows = main.ONOScli2.flows( json_format=True )
         ONOS3_flows = main.ONOScli3.flows( json_format=True )
@@ -527,7 +763,7 @@
         global flows
         flows=[]
         for i in range(1,29):
-            flows.append(main.Mininet2.get_flowTable("s"+str(i),1.0))
+            flows.append(main.Mininet2.get_flowTable(1.3, "s"+str(i)))
 
         #TODO: Compare switch flow tables with ONOS flow tables
 
@@ -578,7 +814,6 @@
         devices.append( main.ONOScli5.devices() )
         devices.append( main.ONOScli6.devices() )
         devices.append( main.ONOScli7.devices() )
-        '''
         hosts = []
         hosts.append( main.ONOScli1.hosts() )
         hosts.append( main.ONOScli2.hosts() )
@@ -587,7 +822,6 @@
         hosts.append( main.ONOScli5.hosts() )
         hosts.append( main.ONOScli6.hosts() )
         hosts.append( main.ONOScli7.hosts() )
-        '''
         ports = []
         ports.append( main.ONOScli1.ports() )
         ports.append( main.ONOScli2.ports() )
@@ -604,13 +838,98 @@
         links.append( main.ONOScli5.links() )
         links.append( main.ONOScli6.links() )
         links.append( main.ONOScli7.links() )
+        clusters = []
+        clusters.append( main.ONOScli1.clusters() )
+        clusters.append( main.ONOScli2.clusters() )
+        clusters.append( main.ONOScli3.clusters() )
+        clusters.append( main.ONOScli4.clusters() )
+        clusters.append( main.ONOScli5.clusters() )
+        clusters.append( main.ONOScli6.clusters() )
+        clusters.append( main.ONOScli7.clusters() )
+        paths = []
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli1.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli2.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli3.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli4.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli5.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli6.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli7.topology() )
+        paths.append( temp_topo.get('paths', False) )
+
+        #Compare json objects for hosts, dataplane clusters and paths
+
+        #hosts
+        consistent_hosts_result = main.TRUE
+        for controller in range( len( hosts ) ):
+            if not "Error" in hosts[controller]:
+                if hosts[controller] == hosts[0]:
+                    continue
+                else:#hosts not consistent
+                    main.log.report("hosts from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                    main.log.warn( repr( hosts[controller] ) )
+                    consistent_hosts_result = main.FALSE
+
+            else:
+                main.log.report("Error in getting ONOS hosts from ONOS" + str(controller + 1) )
+                consistent_hosts_result = main.FALSE
+                main.log.warn("ONOS" + str(controller + 1) + " hosts response: " + repr(hosts[controller]) )
+        utilities.assert_equals(expect = main.TRUE,actual=consistent_hosts_result,
+                onpass="Hosts view is consistent across all ONOS nodes",
+                onfail="ONOS nodes have different views of hosts")
+
+        #Strongly connected clusters of devices
+        consistent_clusters_result = main.TRUE
+        for controller in range( len( clusters ) ):
+            if not "Error" in clusters[controller]:
+                if clusters[controller] == clusters[0]:
+                    continue
+                else:#clusters not consistent
+                    main.log.report("clusters from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                    consistent_clusters_result = main.FALSE
+
+            else:
+                main.log.report("Error in getting dataplane clusters from ONOS" + str(controller + 1) )
+                consistent_clusters_result = main.FALSE
+                main.log.warn("ONOS" + str(controller + 1) + " clusters response: " + repr(clusters[controller]) )
+        utilities.assert_equals(expect = main.TRUE,actual=consistent_clusters_result,
+                onpass="Clusters view is consistent across all ONOS nodes",
+                onfail="ONOS nodes have different views of clusters")
+        num_clusters =  len(json.loads(clusters[0])) #there should always only be one cluster
+        utilities.assert_equals(expect = 1, actual = num_clusters,
+                onpass="ONOS shows 1 SCC",
+                onfail="ONOS shows "+str(num_clusters) +" SCCs")
+
+
+        #paths
+        consistent_paths_result = main.TRUE
+        for controller in range( len( paths ) ):
+            if not "Error" in paths[controller]:
+                if paths[controller] == paths[0]:
+                    continue
+                else:#paths not consistent
+                    main.log.report("paths from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                    consistent_paths_result = main.FALSE
+
+            else:
+                main.log.report("Error in getting paths from ONOS" + str(controller + 1) )
+                consistent_paths_result = main.FALSE
+                main.log.warn("ONOS" + str(controller + 1) + " paths response: " + repr(paths[controller]) )
+        utilities.assert_equals(expect = main.TRUE,actual=consistent_paths_result,
+                onpass="Paths count is consistent across all ONOS nodes",
+                onfail="ONOS nodes have different counts of paths")
 
 
         main.step("Comparing ONOS topology to MN")
         devices_results = main.TRUE
         ports_results = main.TRUE
         links_results = main.TRUE
-        for controller in range(7): #TODO parameterize the number of controllers
+        for controller in range(num_controllers):
             if devices[controller] or not "Error" in devices[controller]:
                 current_devices_result =  main.Mininet1.compare_switches(MNTopo, json.loads(devices[controller]))
             else:
@@ -639,14 +958,16 @@
             ports_results = ports_results and current_ports_result
             links_results = links_results and current_links_result
 
-        topo_result = devices_results and ports_results and links_results
+        topo_result = devices_results and ports_results and links_results\
+                and consistent_hosts_result and consistent_clusters_result\
+                and consistent_paths_result
         utilities.assert_equals(expect=main.TRUE, actual=topo_result,
                 onpass="Topology Check Test successful",
                 onfail="Topology Check Test NOT successful")
 
         final_assert = main.TRUE
         final_assert = final_assert and topo_result and flow_check \
-                and intent_check and consistent_mastership
+                and intent_check and consistent_mastership and roles_not_null
         utilities.assert_equals(expect=main.TRUE, actual=final_assert,
                 onpass="State check successful",
                 onfail="State check NOT successful")
@@ -708,6 +1029,24 @@
         import json
         main.case("Running ONOS Constant State Tests")
 
+        #Assert that each device has a master
+        ONOS1_master_not_null = main.ONOScli1.roles_not_null()
+        ONOS2_master_not_null = main.ONOScli2.roles_not_null()
+        ONOS3_master_not_null = main.ONOScli3.roles_not_null()
+        ONOS4_master_not_null = main.ONOScli4.roles_not_null()
+        ONOS5_master_not_null = main.ONOScli5.roles_not_null()
+        ONOS6_master_not_null = main.ONOScli6.roles_not_null()
+        ONOS7_master_not_null = main.ONOScli7.roles_not_null()
+        roles_not_null = ONOS1_master_not_null and ONOS2_master_not_null and\
+                ONOS3_master_not_null and ONOS4_master_not_null and\
+                ONOS5_master_not_null and ONOS6_master_not_null and\
+                ONOS7_master_not_null
+        utilities.assert_equals(expect = main.TRUE,actual=roles_not_null,
+                onpass="Each device has a master",
+                onfail="Some devices don't have a master assigned")
+
+
+
         main.step("Check if switch roles are consistent across all nodes")
         ONOS1_mastership = main.ONOScli1.roles()
         ONOS2_mastership = main.ONOScli2.roles()
@@ -739,7 +1078,6 @@
                 and ONOS1_mastership == ONOS5_mastership\
                 and ONOS1_mastership == ONOS6_mastership\
                 and ONOS1_mastership == ONOS7_mastership:
-                    #mastership_state = ONOS1_mastership
                     consistent_mastership = main.TRUE
                     main.log.report("Switch roles are consistent across all ONOS nodes")
         else:
@@ -785,7 +1123,7 @@
                 onpass="Mastership of Switches was not changed",
                 onfail="Mastership of some switches changed")
         #NOTE: we expect mastership to change on controller failure
-        mastership_check = mastership_check #and consistent_mastership
+        mastership_check = consistent_mastership
 
 
 
@@ -822,35 +1160,53 @@
                     intent_check = main.TRUE
                     main.log.report("Intents are consistent across all ONOS nodes")
         else:
-            main.log.warn("ONOS1 intents: ", json.dumps(json.loads(ONOS1_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS2 intents: ", json.dumps(json.loads(ONOS2_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS3 intents: ", json.dumps(json.loads(ONOS3_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS4 intents: ", json.dumps(json.loads(ONOS4_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS5 intents: ", json.dumps(json.loads(ONOS5_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS6 intents: ", json.dumps(json.loads(ONOS6_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS7 intents: ", json.dumps(json.loads(ONOS7_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
+            main.log.warn("ONOS1 intents: ")
+            print json.dumps(json.loads(ONOS1_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS2 intents: ")
+            print json.dumps(json.loads(ONOS2_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS3 intents: ")
+            print json.dumps(json.loads(ONOS3_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS4 intents: ")
+            print json.dumps(json.loads(ONOS4_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS5 intents: ")
+            print json.dumps(json.loads(ONOS5_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS6 intents: ")
+            print json.dumps(json.loads(ONOS6_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS7 intents: ")
+            print json.dumps(json.loads(ONOS7_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
         utilities.assert_equals(expect = main.TRUE,actual=intent_check,
                 onpass="Intents are consistent across all ONOS nodes",
                 onfail="ONOS nodes have different views of intents")
 
+        #NOTE: Hazelcast has no durability, so intents are lost across system restarts
+        '''
         main.step("Compare current intents with intents before the failure")
+        #NOTE: this requires case 5 to pass for intent_state to be set.
+        #      maybe we should stop the test if that fails?
         if intent_state == ONOS1_intents:
             same_intents = main.TRUE
             main.log.report("Intents are consistent with before failure")
         #TODO: possibly the states have changed? we may need to figure out what the aceptable states are
         else:
+            try:
+                main.log.warn("ONOS1 intents: ")
+                print json.dumps(json.loads(ONOS1_intents),
+                    sort_keys=True, indent=4, separators=(',', ': '))
+            except:
+                pass
             same_intents = main.FALSE
         utilities.assert_equals(expect = main.TRUE,actual=same_intents,
                 onpass="Intents are consistent with before failure",
                 onfail="The Intents changed during failure")
         intent_check = intent_check and same_intents
+        '''
 
 
 
@@ -859,12 +1215,12 @@
         flows2=[]
         for i in range(28):
             main.log.info("Checking flow table on s" + str(i+1))
-            tmp_flows = main.Mininet2.get_flowTable("s"+str(i+1),1.0)
+            tmp_flows = main.Mininet2.get_flowTable(1.3, "s"+str(i+1))
             flows2.append(tmp_flows)
-            Flow_Tables = Flow_Tables and main.Mininet2.flow_comp(flow1=flows[i],flow2=tmp_flows)
+            temp_result = main.Mininet2.flow_comp(flow1=flows[i],flow2=tmp_flows)
+            Flow_Tables = Flow_Tables and temp_result
             if Flow_Tables == main.FALSE:
                 main.log.info("Differences in flow table for switch: "+str(i+1))
-                break
         if Flow_Tables == main.TRUE:
             main.log.report("No changes were found in the flow tables")
         utilities.assert_equals(expect=main.TRUE,actual=Flow_Tables,
@@ -880,7 +1236,7 @@
         #NOTE: checkForLoss returns main.FALSE with 0% packet loss
         for i in range(8,18):
             main.log.info("Checking for a loss in pings along flow from s" + str(i))
-            Loss_In_Pings = Loss_In_Pings or main.Mininet2.checkForLoss("/tmp/ping.h"+str(i))
+            Loss_In_Pings = main.Mininet2.checkForLoss("/tmp/ping.h"+str(i)) or Loss_In_Pings
         if Loss_In_Pings == main.TRUE:
             main.log.info("Loss in ping detected")
         elif Loss_In_Pings == main.ERROR:
@@ -891,10 +1247,37 @@
         utilities.assert_equals(expect=main.FALSE,actual=Loss_In_Pings,
                 onpass="No Loss of connectivity",
                 onfail="Loss of dataplane connectivity detected")
+        #NOTE: Since intents are not persisted with Hazelcast, we expect this
+        Loss_In_Pings = main.FALSE
 
 
-        #TODO:add topology to this or leave as a seperate case?
-        result = mastership_check and intent_check and Flow_Tables and (not Loss_In_Pings)
+        #Test of LeadershipElection
+        leader_list = []
+        leader_result = main.TRUE
+        for controller in range(1,num_controllers+1):
+            node = getattr( main, ( 'ONOScli' + str( controller ) ) )#loop through ONOScli handlers
+            leaderN = node.election_test_leader()
+            leader_list.append(leaderN)
+            if leaderN == main.FALSE:
+                #error in  response
+                main.log.report("Something is wrong with election_test_leader function, check the error logs")
+                leader_result = main.FALSE
+            elif leaderN == None:
+                main.log.report("ONOS"+str(controller) + " shows no leader for the election-app was elected after the old one died")
+                leader_result = main.FALSE
+        if len( set( leader_list ) ) != 1:
+            leader_result = main.FALSE
+            main.log.error("Inconsistent view of leader for the election test app")
+            #TODO: print the list
+        if leader_result:
+            main.log.report("Leadership election tests passed(consistent view of leader across listeners and a new leader was re-elected after restart)")
+        utilities.assert_equals(expect=main.TRUE, actual=leader_result,
+                onpass="Leadership election passed",
+                onfail="Something went wrong with Leadership election")
+
+
+        result = mastership_check and intent_check and Flow_Tables and (not Loss_In_Pings) and roles_not_null\
+                and leader_result
         result = int(result)
         if result == main.TRUE:
             main.log.report("Constant State Tests Passed")
@@ -936,87 +1319,173 @@
         ports_results = main.TRUE
         links_results = main.TRUE
         topo_result = main.FALSE
-        start_time = time.time()
         elapsed = 0
         count = 0
-        while topo_result == main.FALSE and elapsed < 120:
+        main.step("Collecting topology information from ONOS")
+        start_time = time.time()
+        while topo_result == main.FALSE and elapsed < 60:
             count = count + 1
-            try:
-                main.step("Collecting topology information from ONOS")
-                devices = []
-                devices.append( main.ONOScli1.devices() )
-                devices.append( main.ONOScli2.devices() )
-                devices.append( main.ONOScli3.devices() )
-                devices.append( main.ONOScli4.devices() )
-                devices.append( main.ONOScli5.devices() )
-                devices.append( main.ONOScli6.devices() )
-                devices.append( main.ONOScli7.devices() )
-                '''
-                hosts = []
-                hosts.append( main.ONOScli1.hosts() )
-                hosts.append( main.ONOScli2.hosts() )
-                hosts.append( main.ONOScli3.hosts() )
-                hosts.append( main.ONOScli4.hosts() )
-                hosts.append( main.ONOScli5.hosts() )
-                hosts.append( main.ONOScli6.hosts() )
-                hosts.append( main.ONOScli7.hosts() )
-                '''
-                ports = []
-                ports.append( main.ONOScli1.ports() )
-                ports.append( main.ONOScli2.ports() )
-                ports.append( main.ONOScli3.ports() )
-                ports.append( main.ONOScli4.ports() )
-                ports.append( main.ONOScli5.ports() )
-                ports.append( main.ONOScli6.ports() )
-                ports.append( main.ONOScli7.ports() )
-                links = []
-                links.append( main.ONOScli1.links() )
-                links.append( main.ONOScli2.links() )
-                links.append( main.ONOScli3.links() )
-                links.append( main.ONOScli4.links() )
-                links.append( main.ONOScli5.links() )
-                links.append( main.ONOScli6.links() )
-                links.append( main.ONOScli7.links() )
+            if count > 1:
+                MNTopo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
+            cli_start = time.time()
+            devices = []
+            devices.append( main.ONOScli1.devices() )
+            devices.append( main.ONOScli2.devices() )
+            devices.append( main.ONOScli3.devices() )
+            devices.append( main.ONOScli4.devices() )
+            devices.append( main.ONOScli5.devices() )
+            devices.append( main.ONOScli6.devices() )
+            devices.append( main.ONOScli7.devices() )
+            hosts = []
+            hosts.append( main.ONOScli1.hosts() )
+            hosts.append( main.ONOScli2.hosts() )
+            hosts.append( main.ONOScli3.hosts() )
+            hosts.append( main.ONOScli4.hosts() )
+            hosts.append( main.ONOScli5.hosts() )
+            hosts.append( main.ONOScli6.hosts() )
+            hosts.append( main.ONOScli7.hosts() )
+            ports = []
+            ports.append( main.ONOScli1.ports() )
+            ports.append( main.ONOScli2.ports() )
+            ports.append( main.ONOScli3.ports() )
+            ports.append( main.ONOScli4.ports() )
+            ports.append( main.ONOScli5.ports() )
+            ports.append( main.ONOScli6.ports() )
+            ports.append( main.ONOScli7.ports() )
+            links = []
+            links.append( main.ONOScli1.links() )
+            links.append( main.ONOScli2.links() )
+            links.append( main.ONOScli3.links() )
+            links.append( main.ONOScli4.links() )
+            links.append( main.ONOScli5.links() )
+            links.append( main.ONOScli6.links() )
+            links.append( main.ONOScli7.links() )
+            clusters = []
+            clusters.append( main.ONOScli1.clusters() )
+            clusters.append( main.ONOScli2.clusters() )
+            clusters.append( main.ONOScli3.clusters() )
+            clusters.append( main.ONOScli4.clusters() )
+            clusters.append( main.ONOScli5.clusters() )
+            clusters.append( main.ONOScli6.clusters() )
+            clusters.append( main.ONOScli7.clusters() )
+            paths = []
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli1.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli2.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli3.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli4.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli5.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli6.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli7.topology() )
+            paths.append( temp_topo.get('paths', False) )
 
-                for controller in range(7): #TODO parameterize the number of controllers
-                    if devices[controller] or not "Error" in devices[controller]:
-                        current_devices_result =  main.Mininet1.compare_switches(MNTopo, json.loads(devices[controller]))
-                    else:
-                        current_devices_result = main.FALSE
-                    utilities.assert_equals(expect=main.TRUE, actual=current_devices_result,
-                            onpass="ONOS"+str(int(controller+1))+" Switches view is correct",
-                            onfail="ONOS"+str(int(controller+1))+" Switches view is incorrect")
 
-                    if ports[controller] or not "Error" in ports[controller]:
-                        current_ports_result =  main.Mininet1.compare_ports(MNTopo, json.loads(ports[controller]))
-                    else:
-                        current_ports_result = main.FALSE
-                    utilities.assert_equals(expect=main.TRUE, actual=current_ports_result,
-                            onpass="ONOS"+str(int(controller+1))+" ports view is correct",
-                            onfail="ONOS"+str(int(controller+1))+" ports view is incorrect")
+            elapsed = time.time() - start_time
+            cli_time = time.time() - cli_start
+            print "CLI time: " + str(cli_time)
 
-                    if links[controller] or not "Error" in links[controller]:
-                        current_links_result =  main.Mininet1.compare_links(MNTopo, json.loads(links[controller]))
-                    else:
-                        current_links_result = main.FALSE
-                    utilities.assert_equals(expect=main.TRUE, actual=current_links_result,
-                            onpass="ONOS"+str(int(controller+1))+" links view is correct",
-                            onfail="ONOS"+str(int(controller+1))+" links view is incorrect")
-            except:
-                main.log.error("something went wrong in topo comparison")
-                main.log.warn( repr( devices ) )
-                main.log.warn( repr( ports ) )
-                main.log.warn( repr( links ) )
+            for controller in range(num_controllers):
+                if devices[controller] or not "Error" in devices[controller]:
+                    current_devices_result =  main.Mininet1.compare_switches(MNTopo, json.loads(devices[controller]))
+                else:
+                    current_devices_result = main.FALSE
+                utilities.assert_equals(expect=main.TRUE, actual=current_devices_result,
+                        onpass="ONOS"+str(int(controller+1))+" Switches view is correct",
+                        onfail="ONOS"+str(int(controller+1))+" Switches view is incorrect")
 
+                if ports[controller] or not "Error" in ports[controller]:
+                    current_ports_result =  main.Mininet1.compare_ports(MNTopo, json.loads(ports[controller]))
+                else:
+                    current_ports_result = main.FALSE
+                utilities.assert_equals(expect=main.TRUE, actual=current_ports_result,
+                        onpass="ONOS"+str(int(controller+1))+" ports view is correct",
+                        onfail="ONOS"+str(int(controller+1))+" ports view is incorrect")
+
+                if links[controller] or not "Error" in links[controller]:
+                    current_links_result =  main.Mininet1.compare_links(MNTopo, json.loads(links[controller]))
+                else:
+                    current_links_result = main.FALSE
+                utilities.assert_equals(expect=main.TRUE, actual=current_links_result,
+                        onpass="ONOS"+str(int(controller+1))+" links view is correct",
+                        onfail="ONOS"+str(int(controller+1))+" links view is incorrect")
             devices_results = devices_results and current_devices_result
             ports_results = ports_results and current_ports_result
             links_results = links_results and current_links_result
-            topo_result = devices_results and ports_results and links_results
-            elapsed = time.time() - start_time
-        time_threshold = elapsed < 1
-        topo_result = topo_result and time_threshold
-        #TODO make sure this step is non-blocking. IE add a timeout
-        main.log.report("Very crass estimate for topology discovery/convergence: " +\
+
+            #Compare json objects for hosts, dataplane clusters and paths
+
+            #hosts
+            consistent_hosts_result = main.TRUE
+            for controller in range( len( hosts ) ):
+                if not "Error" in hosts[controller]:
+                    if hosts[controller] == hosts[0]:
+                        continue
+                    else:#hosts not consistent
+                        main.log.report("hosts from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                        main.log.warn( repr( hosts[controller] ) )
+                        consistent_hosts_result = main.FALSE
+
+                else:
+                    main.log.report("Error in getting ONOS hosts from ONOS" + str(controller + 1) )
+                    consistent_hosts_result = main.FALSE
+                    main.log.warn("ONOS" + str(controller + 1) + " hosts response: " + repr(hosts[controller]) )
+            utilities.assert_equals(expect = main.TRUE,actual=consistent_hosts_result,
+                    onpass="Hosts view is consistent across all ONOS nodes",
+                    onfail="ONOS nodes have different views of hosts")
+
+            #Strongly connected clusters of devices
+            consistent_clusters_result = main.TRUE
+            for controller in range( len( clusters ) ):
+                if not "Error" in clusters[controller]:
+                    if clusters[controller] == clusters[0]:
+                        continue
+                    else:#clusters not consistent
+                        main.log.report("clusters from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                        consistent_clusters_result = main.FALSE
+
+                else:
+                    main.log.report("Error in getting dataplane clusters from ONOS" + str(controller + 1) )
+                    consistent_clusters_result = main.FALSE
+                    main.log.warn("ONOS" + str(controller + 1) + " clusters response: " + repr(clusters[controller]) )
+            utilities.assert_equals(expect = main.TRUE,actual=consistent_clusters_result,
+                    onpass="Clusters view is consistent across all ONOS nodes",
+                    onfail="ONOS nodes have different views of clusters")
+            num_clusters =  len(json.loads(clusters[0])) #there should always only be one cluster
+            utilities.assert_equals(expect = 1, actual = num_clusters,
+                    onpass="ONOS shows 1 SCC",
+                    onfail="ONOS shows "+str(num_clusters) +" SCCs")
+
+
+            #paths
+            consistent_paths_result = main.TRUE
+            for controller in range( len( paths ) ):
+                if not "Error" in paths[controller]:
+                    if paths[controller] == paths[0]:
+                        continue
+                    else:#paths not consistent
+                        main.log.report("paths from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                        consistent_paths_result = main.FALSE
+
+                else:
+                    main.log.report("Error in getting paths from ONOS" + str(controller + 1) )
+                    consistent_paths_result = main.FALSE
+                    main.log.warn("ONOS" + str(controller + 1) + " paths response: " + repr(paths[controller]) )
+            utilities.assert_equals(expect = main.TRUE,actual=consistent_paths_result,
+                    onpass="Paths count is consistent across all ONOS nodes",
+                    onfail="ONOS nodes have different counts of paths")
+
+
+            topo_result = devices_results and ports_results and links_results\
+                    and consistent_hosts_result and consistent_clusters_result and consistent_paths_result
+
+        topo_result = topo_result and int(count <= 2)
+        note = "note it takes about "+str( int(cli_time) )+" seconds for the test to make all the cli calls to fetch the topology from each ONOS instance"
+        main.log.report("Very crass estimate for topology discovery/convergence("+ str(note) + "): " +\
                 str(elapsed) + " seconds, " + str(count) +" tries" )
         utilities.assert_equals(expect=main.TRUE, actual=topo_result,
                 onpass="Topology Check Test successful",
@@ -1031,7 +1500,7 @@
         '''
         #NOTE: You should probably run a topology check after this
 
-        link_sleep = int(main.params['timers']['LinkDiscovery'])
+        link_sleep = float(main.params['timers']['LinkDiscovery'])
 
         description = "Turn off a link to ensure that Link Discovery is working properly"
         main.log.report(description)
@@ -1053,7 +1522,7 @@
         '''
         #NOTE: You should probably run a topology check after this
 
-        link_sleep = int(main.params['timers']['LinkDiscovery'])
+        link_sleep = float(main.params['timers']['LinkDiscovery'])
 
         description = "Restore a link to ensure that Link Discovery is working properly"
         main.log.report(description)
@@ -1076,7 +1545,7 @@
         #NOTE: You should probably run a topology check after this
         import time
 
-        switch_sleep = int(main.params['timers']['SwitchDiscovery'])
+        switch_sleep = float(main.params['timers']['SwitchDiscovery'])
 
         description = "Killing a switch to ensure it is discovered correctly"
         main.log.report(description)
@@ -1085,13 +1554,18 @@
         #TODO: Make this switch parameterizable
         main.step("Kill s28 ")
         main.log.report("Deleting s28")
-        #FIXME: use new dynamic topo functions
         main.Mininet1.del_switch("s28")
         main.log.info("Waiting " + str(switch_sleep) + " seconds for switch down to be discovered")
         time.sleep(switch_sleep)
+        device = main.ONOScli1.get_device(dpid="0028")
         #Peek at the deleted switch
-        main.log.warn(main.ONOScli1.get_device(dpid="0028"))
-        #TODO do some sort of check here
+        main.log.warn( str(device) )
+        result = main.FALSE
+        if device and device['available'] == False:
+            result = main.TRUE
+        utilities.assert_equals(expect=main.TRUE,actual=result,
+                onpass="Kill switch succesful",
+                onfail="Failed to kill switch?")
 
     def CASE12 (self, main) :
         '''
@@ -1099,7 +1573,8 @@
         '''
         #NOTE: You should probably run a topology check after this
         import time
-        #FIXME: use new dynamic topo functions
+
+        switch_sleep = float(main.params['timers']['SwitchDiscovery'])
         description = "Adding a switch to ensure it is discovered correctly"
         main.log.report(description)
         main.case(description)
@@ -1111,7 +1586,7 @@
         main.Mininet1.add_link('s28', 's3')
         main.Mininet1.add_link('s28', 's6')
         main.Mininet1.add_link('s28', 'h28')
-        main.Mininet1.assign_sw_controller(sw="28",count=7,
+        main.Mininet1.assign_sw_controller(sw="28",count=num_controllers,
                 ip1=ONOS1_ip,port1=ONOS1_port,
                 ip2=ONOS2_ip,port2=ONOS2_port,
                 ip3=ONOS3_ip,port3=ONOS3_port,
@@ -1121,9 +1596,15 @@
                 ip7=ONOS7_ip,port7=ONOS7_port)
         main.log.info("Waiting " + str(switch_sleep) + " seconds for switch up to be discovered")
         time.sleep(switch_sleep)
-        #Peek at the added switch
-        main.log.warn(main.ONOScli1.get_device(dpid="0028"))
-        #TODO do some sort of check here
+        device = main.ONOScli1.get_device(dpid="0028")
+        #Peek at the deleted switch
+        main.log.warn( str(device) )
+        result = main.FALSE
+        if device and device['available'] == True:
+            result = main.TRUE
+        utilities.assert_equals(expect=main.TRUE,actual=result,
+                onpass="add switch succesful",
+                onfail="Failed to add switch?")
 
     def CASE13 (self, main) :
         '''
@@ -1131,14 +1612,41 @@
         '''
         import os
         import time
+        #printing colors to terminal
+        colors = {}
+        colors['cyan']   = '\033[96m'
+        colors['purple'] = '\033[95m'
+        colors['blue']   = '\033[94m'
+        colors['green']  = '\033[92m'
+        colors['yellow'] = '\033[93m'
+        colors['red']    = '\033[91m'
+        colors['end']    = '\033[0m'
         description = "Test Cleanup"
         main.log.report(description)
         main.case(description)
         main.step("Killing tcpdumps")
         main.Mininet2.stop_tcpdump()
 
+        main.step("Checking ONOS Logs for errors")
+        print colors['purple'] + "Checking logs for errors on ONOS1:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS1_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS2:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS2_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS3:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS3_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS4:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS4_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS5:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS5_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS6:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS6_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS7:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS7_ip)
+
         main.step("Copying MN pcap and ONOS log files to test station")
         testname = main.TEST
+        teststation_user = main.params['TESTONUSER']
+        teststation_IP = main.params['TESTONIP']
         #NOTE: MN Pcap file is being saved to ~/packet_captures
         #       scp this file as MN and TestON aren't necessarily the same vm
         #FIXME: scp
@@ -1150,19 +1658,26 @@
         #NOTE: must end in /
         dst_dir = "~/packet_captures/"
         for f in log_files:
-            main.ONOSbench.secureCopy( "sdn", ONOS1_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS1_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS1-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS2_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS2_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS2-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS3_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS3_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS3-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS4_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS4_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS4-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS5_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS5_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS5-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS6_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS6_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS6-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS7_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS7_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS7-"+f )
 
         #std*.log's
@@ -1172,24 +1687,29 @@
         #NOTE: must end in /
         dst_dir = "~/packet_captures/"
         for f in log_files:
-            main.ONOSbench.secureCopy( "sdn", ONOS1_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS1_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS1-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS2_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS2_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS2-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS3_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS3_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS3-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS4_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS4_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS4-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS5_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS5_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS5-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS6_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS6_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS6-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS7_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS7_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS7-"+f )
 
 
-
-
         #sleep so scp can finish
         time.sleep(10)
         main.step("Packing and rotating pcap archives")
@@ -1200,3 +1720,139 @@
         utilities.assert_equals(expect=main.TRUE, actual=main.TRUE,
                 onpass="Test cleanup successful",
                 onfail="Test cleanup NOT successful")
+
+    def CASE14 ( self, main ) :
+        '''
+        start election app on all onos nodes
+        '''
+        leader_result = main.TRUE
+        #install app on onos 1
+        main.log.info("Install leadership election app")
+        main.ONOScli1.feature_install("onos-app-election")
+        #wait for election
+        #check for leader
+        leader = main.ONOScli1.election_test_leader()
+        #verify leader is ONOS1
+        if leader == ONOS1_ip:
+            #all is well
+            pass
+        elif leader == None:
+            #No leader elected
+            main.log.report("No leader was elected")
+            leader_result = main.FALSE
+        elif leader == main.FALSE:
+            #error in  response
+            #TODO: add check for "Command not found:" in the driver, this means the app isn't loaded
+            main.log.report("Something is wrong with election_test_leader function, check the error logs")
+            leader_result = main.FALSE
+        else:
+            #error in  response
+            main.log.report("Unexpected response from election_test_leader function:'"+str(leader)+"'")
+            leader_result = main.FALSE
+
+
+
+
+        #install on other nodes and check for leader.
+        #Should be onos1 and each app should show the same leader
+        for controller in range(2,num_controllers+1):
+            node = getattr( main, ( 'ONOScli' + str( controller ) ) )#loop through ONOScli handlers
+            node.feature_install("onos-app-election")
+            leaderN = node.election_test_leader()
+            #verify leader is ONOS1
+            if leaderN == ONOS1_ip:
+                #all is well
+                pass
+            elif leaderN == main.FALSE:
+                #error in  response
+                #TODO: add check for "Command not found:" in the driver, this means the app isn't loaded
+                main.log.report("Something is wrong with election_test_leader function, check the error logs")
+                leader_result = main.FALSE
+            elif leader != leaderN:
+                leader_result = main.FALSE
+                main.log.report("ONOS" + str(controller) + " sees "+str(leaderN) +
+                        " as the leader of the election app. Leader should be "+str(leader) )
+        if leader_result:
+            main.log.report("Leadership election tests passed(consistent view of leader across listeners and a leader was elected)")
+        utilities.assert_equals(expect=main.TRUE, actual=leader_result,
+                onpass="Leadership election passed",
+                onfail="Something went wrong with Leadership election")
+
+    def CASE15 ( self, main ) :
+        '''
+        Check that Leadership Election is still functional
+        '''
+        leader_result = main.TRUE
+        description = "Check that Leadership Election is still functional"
+        main.log.report(description)
+        main.case(description)
+        main.step("Find current leader and withdraw")
+        leader = main.ONOScli1.election_test_leader()
+        #TODO: do some sanity checking on leader before using it
+        withdraw_result = main.FALSE
+        if leader == ONOS1_ip:
+            old_leader = getattr( main, "ONOScli1" )
+        elif leader == ONOS2_ip:
+            old_leader = getattr( main, "ONOScli2" )
+        elif leader == ONOS3_ip:
+            old_leader = getattr( main, "ONOScli3" )
+        elif leader == ONOS4_ip:
+            old_leader = getattr( main, "ONOScli4" )
+        elif leader == ONOS5_ip:
+            old_leader = getattr( main, "ONOScli5" )
+        elif leader == ONOS6_ip:
+            old_leader = getattr( main, "ONOScli6" )
+        elif leader == ONOS7_ip:
+            old_leader = getattr( main, "ONOScli7" )
+        elif leader == None or leader == main.FALSE:
+            main.log.report("Leader for the election app should be an ONOS node,"\
+                    +"instead got '"+str(leader)+"'")
+            leader_result = main.FALSE
+        withdraw_result = old_leader.election_test_withdraw()
+
+
+        main.step("Make sure new leader is elected")
+        leader_list = []
+        for controller in range(1,num_controllers+1):
+            node = getattr( main, ( 'ONOScli' + str( controller ) ) )#loop through ONOScli handlers
+            leader_list.append( node.election_test_leader() )
+        for leaderN in leader_list:
+            if leaderN == leader:
+                main.log.report("ONOS"+str(controller)+" still sees " + str(leader) +\
+                        " as leader after they withdrew")
+                leader_result = main.FALSE
+            elif leaderN == main.FALSE:
+                #error in  response
+                #TODO: add check for "Command not found:" in the driver, this means the app isn't loaded
+                main.log.report("Something is wrong with election_test_leader function, check the error logs")
+                leader_result = main.FALSE
+        consistent_leader = main.FALSE
+        if len( set( leader_list ) ) == 1:
+            main.log.info("Each Election-app sees '"+str(leader_list[0])+"' as the leader")
+            consistent_leader = main.TRUE
+        else:
+            main.log.report("Inconsistent responses for leader of Election-app:")
+            for n in range(len(leader_list)):
+                main.log.report("ONOS" + str(n+1) + " response: " + str(leader_list[n]) )
+        if leader_result:
+            main.log.report("Leadership election tests passed(consistent view of leader across listeners and a new leader was elected when the old leader resigned)")
+        utilities.assert_equals(expect=main.TRUE, actual=leader_result,
+                onpass="Leadership election passed",
+                onfail="Something went wrong with Leadership election")
+
+
+        main.step("Run for election on old leader(just so everyone is in the hat)")
+        run_result = old_leader.election_test_run()
+        if consistent_leader == main.TRUE:
+            after_run = main.ONOScli1.election_test_leader()
+            #verify leader didn't just change
+            if after_run == leader_list[0]:
+                leader_result = main.TRUE
+            else:
+                leader_result = main.FALSE
+        #TODO: assert on  run and withdraw results?
+
+        utilities.assert_equals(expect=main.TRUE, actual=leader_result,
+                onpass="Leadership election passed",
+                onfail="Something went wrong with Leadership election after the old leader re-ran for election")
+
diff --git a/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.params b/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.params
index 0a8bd57..78e0c83 100644
--- a/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.params
+++ b/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.params
@@ -1,9 +1,10 @@
 <PARAMS>
-    <testcases>1,2,8,3,4,5,[6],7,8,4,9,8,4,10,8,4,11,8,4,12,8,4,13</testcases>
+    <testcases>1,2,8,3,4,5,14,[6],8,7,4,15,9,8,4,10,8,4,11,8,4,12,8,4,13</testcases>
     <ENV>
     <cellName>HA</cellName>
     </ENV>
     <Git>False</Git>
+    <num_controllers> 7 </num_controllers>
 
     <CTRL>
         <ip1>10.128.30.11</ip1>
@@ -28,7 +29,7 @@
         <port7>6633</port7>
     </CTRL>
     <TESTONUSER>admin</TESTONUSER>
-    <TESTONIP>10.128.30.10</TESTONIP>
+    <TESTONIP>10.128.30.9</TESTONIP>
     <PING>
         <source1>h8</source1>
         <source2>h9</source2>
@@ -52,8 +53,8 @@
         <target10>10.0.0.27</target10>
     </PING>
     <timers>
-        <LinkDiscovery>2</LinkDiscovery>
-        <SwitchDiscovery>2</SwitchDiscovery>
+        <LinkDiscovery>.2</LinkDiscovery>
+        <SwitchDiscovery>.2</SwitchDiscovery>
     </timers>
     <MNtcpdump>
         <intf>eth0</intf>
diff --git a/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.py b/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.py
index 2af775d..b9d2925 100644
--- a/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.py
+++ b/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.py
@@ -16,6 +16,8 @@
 CASE11: Switch down
 CASE12: Switch up
 CASE13: Clean up
+CASE14: start election app on all onos nodes
+CASE15: Check that Leadership Election is still functional
 '''
 class HATestMinorityRestart:
 
@@ -61,6 +63,7 @@
         global ONOS6_port
         global ONOS7_ip
         global ONOS7_port
+        global num_controllers
 
         ONOS1_ip = main.params['CTRL']['ip1']
         ONOS1_port = main.params['CTRL']['port1']
@@ -76,13 +79,14 @@
         ONOS6_port = main.params['CTRL']['port6']
         ONOS7_ip = main.params['CTRL']['ip7']
         ONOS7_port = main.params['CTRL']['port7']
+        num_controllers = int(main.params['num_controllers'])
 
 
         main.step("Applying cell variable to environment")
         cell_result = main.ONOSbench.set_cell(cell_name)
         verify_result = main.ONOSbench.verify_cell()
 
-        #FIXME:this is short term fix 
+        #FIXME:this is short term fix
         main.log.report("Removing raft logs")
         main.ONOSbench.onos_remove_raft_logs()
         main.log.report("Uninstalling ONOS")
@@ -143,31 +147,33 @@
 
 
         main.step("Checking if ONOS is up yet")
-        #TODO: Refactor
-        # check bundle:list?
-        onos1_isup = main.ONOSbench.isup(ONOS1_ip)
-        if not onos1_isup:
-            main.log.report("ONOS1 didn't start!")
-        onos2_isup = main.ONOSbench.isup(ONOS2_ip)
-        if not onos2_isup:
-            main.log.report("ONOS2 didn't start!")
-        onos3_isup = main.ONOSbench.isup(ONOS3_ip)
-        if not onos3_isup:
-            main.log.report("ONOS3 didn't start!")
-        onos4_isup = main.ONOSbench.isup(ONOS4_ip)
-        if not onos4_isup:
-            main.log.report("ONOS4 didn't start!")
-        onos5_isup = main.ONOSbench.isup(ONOS5_ip)
-        if not onos5_isup:
-            main.log.report("ONOS5 didn't start!")
-        onos6_isup = main.ONOSbench.isup(ONOS6_ip)
-        if not onos6_isup:
-            main.log.report("ONOS6 didn't start!")
-        onos7_isup = main.ONOSbench.isup(ONOS7_ip)
-        if not onos7_isup:
-            main.log.report("ONOS7 didn't start!")
-        onos_isup_result = onos1_isup and onos2_isup and onos3_isup\
-                and onos4_isup and onos5_isup and onos6_isup and onos7_isup
+        #TODO check bundle:list?
+        for i in range(2):
+            onos1_isup = main.ONOSbench.isup(ONOS1_ip)
+            if not onos1_isup:
+                main.log.report("ONOS1 didn't start!")
+            onos2_isup = main.ONOSbench.isup(ONOS2_ip)
+            if not onos2_isup:
+                main.log.report("ONOS2 didn't start!")
+            onos3_isup = main.ONOSbench.isup(ONOS3_ip)
+            if not onos3_isup:
+                main.log.report("ONOS3 didn't start!")
+            onos4_isup = main.ONOSbench.isup(ONOS4_ip)
+            if not onos4_isup:
+                main.log.report("ONOS4 didn't start!")
+            onos5_isup = main.ONOSbench.isup(ONOS5_ip)
+            if not onos5_isup:
+                main.log.report("ONOS5 didn't start!")
+            onos6_isup = main.ONOSbench.isup(ONOS6_ip)
+            if not onos6_isup:
+                main.log.report("ONOS6 didn't start!")
+            onos7_isup = main.ONOSbench.isup(ONOS7_ip)
+            if not onos7_isup:
+                main.log.report("ONOS7 didn't start!")
+            onos_isup_result = onos1_isup and onos2_isup and onos3_isup\
+                    and onos4_isup and onos5_isup and onos6_isup and onos7_isup
+            if onos_isup_result == main.TRUE:
+                break
         # TODO: if it becomes an issue, we can retry this step  a few times
 
 
@@ -181,6 +187,7 @@
         cli_results = cli_result1 and cli_result2 and cli_result3 and\
                 cli_result4 and cli_result5 and cli_result6 and cli_result7
 
+
         main.step("Start Packet Capture MN")
         main.Mininet2.start_tcpdump(
                 str(main.params['MNtcpdump']['folder'])+str(main.TEST)+"-MN.pcap",
@@ -197,9 +204,9 @@
                 onfail="Test startup NOT successful")
 
 
-        #if case1_result==main.FALSE:
-        #    main.cleanup()
-        #    main.exit()
+        if case1_result==main.FALSE:
+            main.cleanup()
+            main.exit()
 
     def CASE2(self,main) :
         '''
@@ -209,31 +216,12 @@
         import json
         import re
 
-
-        '''
-        ONOS1_ip = main.params['CTRL']['ip1']
-        ONOS1_port = main.params['CTRL']['port1']
-        ONOS2_ip = main.params['CTRL']['ip2']
-        ONOS2_port = main.params['CTRL']['port2']
-        ONOS3_ip = main.params['CTRL']['ip3']
-        ONOS3_port = main.params['CTRL']['port3']
-        ONOS4_ip = main.params['CTRL']['ip4']
-        ONOS4_port = main.params['CTRL']['port4']
-        ONOS5_ip = main.params['CTRL']['ip5']
-        ONOS5_port = main.params['CTRL']['port5']
-        ONOS6_ip = main.params['CTRL']['ip6']
-        ONOS6_port = main.params['CTRL']['port6']
-        ONOS7_ip = main.params['CTRL']['ip7']
-        ONOS7_port = main.params['CTRL']['port7']
-        '''
-
-
         main.log.report("Assigning switches to controllers")
         main.case("Assigning Controllers")
         main.step("Assign switches to controllers")
 
         for i in range (1,29):
-           main.Mininet1.assign_sw_controller(sw=str(i),count=7,
+           main.Mininet1.assign_sw_controller(sw=str(i),count=num_controllers,
                     ip1=ONOS1_ip,port1=ONOS1_port,
                     ip2=ONOS2_ip,port2=ONOS2_port,
                     ip3=ONOS3_ip,port3=ONOS3_port,
@@ -265,8 +253,217 @@
                 onpass="Switch mastership assigned correctly",
                 onfail="Switches not assigned correctly to controllers")
 
-        #TODO: If assign roles is working reliably then manually 
-        #   assign mastership to the controller we want
+        #Manually assign mastership to the controller we want
+        role_call = main.TRUE
+        role_check = main.TRUE
+
+        device_id = main.ONOScli1.get_device("1000")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS1_ip)
+        if ONOS1_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("2800")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS1_ip)
+        if ONOS1_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("2000")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS2_ip)
+        if ONOS2_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3000")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS2_ip)
+        if ONOS2_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("5000")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS3_ip)
+        if ONOS3_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6000")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS3_ip)
+        if ONOS3_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id =  main.ONOScli1.get_device("3004")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS4_ip)
+        if ONOS4_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3008")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3009")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3010")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3011")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3012")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3013")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3014")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3015")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3016")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3017")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6007")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS6_ip)
+        if ONOS6_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6018")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6019")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6020")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6021")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6022")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6023")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6024")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6025")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6026")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6027")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        utilities.assert_equals(expect = main.TRUE,actual=role_call,
+                onpass="Re-assigned switch mastership to designated controller",
+                onfail="Something wrong with device_role calls")
+
+        utilities.assert_equals(expect = main.TRUE,actual=role_check,
+                onpass="Switches were successfully reassigned to designated controller",
+                onfail="Switches were not successfully reassigned")
+        mastership_check = mastership_check and role_call and role_check
+        utilities.assert_equals(expect = main.TRUE,actual=mastership_check,
+                onpass="Switch mastership correctly assigned",
+                onfail="Error in (re)assigning switch mastership")
 
 
     def CASE3(self,main) :
@@ -283,6 +480,16 @@
         main.step("Discovering  Hosts( Via pingall for now)")
         #FIXME: Once we have a host discovery mechanism, use that instead
 
+        #install onos-app-fwd
+        main.log.info("Install reactive forwarding app")
+        main.ONOScli1.feature_install("onos-app-fwd")
+        main.ONOScli2.feature_install("onos-app-fwd")
+        main.ONOScli3.feature_install("onos-app-fwd")
+        main.ONOScli4.feature_install("onos-app-fwd")
+        main.ONOScli5.feature_install("onos-app-fwd")
+        main.ONOScli6.feature_install("onos-app-fwd")
+        main.ONOScli7.feature_install("onos-app-fwd")
+
         #REACTIVE FWD test
         ping_result = main.FALSE
         time1 = time.time()
@@ -299,22 +506,30 @@
         main.ONOScli5.feature_uninstall("onos-app-fwd")
         main.ONOScli6.feature_uninstall("onos-app-fwd")
         main.ONOScli7.feature_uninstall("onos-app-fwd")
+        #timeout for fwd flows
+        time.sleep(10)
 
         main.step("Add  host intents")
         #TODO:  move the host numbers to params
         import json
         intents_json= json.loads(main.ONOScli1.hosts())
-        intent_add_result = main.FALSE
+        intent_add_result = True
         for i in range(8,18):
             main.log.info("Adding host intent between h"+str(i)+" and h"+str(i+10))
             host1 =  "00:00:00:00:00:" + str(hex(i)[2:]).zfill(2).upper()
             host2 =  "00:00:00:00:00:" + str(hex(i+10)[2:]).zfill(2).upper()
-            #NOTE: get host can return None
-            #TODO: handle this
             host1_id = main.ONOScli1.get_host(host1)['id']
             host2_id = main.ONOScli1.get_host(host2)['id']
-            tmp_result = main.ONOScli1.add_host_intent(host1_id, host2_id )
-            intent_add_result = intent_add_result and tmp_result
+            #NOTE: get host can return None
+            if host1_id and host2_id:
+                tmp_result = main.ONOScli1.add_host_intent(host1_id, host2_id )
+            else:
+                main.log.error("Error, get_host() failed")
+                tmp_result = main.FALSE
+            intent_add_result = bool(intent_add_result and tmp_result)
+        utilities.assert_equals(expect=True, actual=intent_add_result,
+                onpass="Switch mastership correctly assigned",
+                onfail="Error in (re)assigning switch mastership")
         #TODO Check if intents all exist in datastore
         #NOTE: Do we need to print this once the test is working?
         #main.log.info(json.dumps(json.loads(main.ONOScli1.intents(json_format=True)),
@@ -360,6 +575,25 @@
 
         main.step("Get the Mastership of each switch from each controller")
         global mastership_state
+        mastership_state = []
+
+        #Assert that each device has a master
+        ONOS1_master_not_null = main.ONOScli1.roles_not_null()
+        ONOS2_master_not_null = main.ONOScli2.roles_not_null()
+        ONOS3_master_not_null = main.ONOScli3.roles_not_null()
+        ONOS4_master_not_null = main.ONOScli4.roles_not_null()
+        ONOS5_master_not_null = main.ONOScli5.roles_not_null()
+        ONOS6_master_not_null = main.ONOScli6.roles_not_null()
+        ONOS7_master_not_null = main.ONOScli7.roles_not_null()
+        roles_not_null = ONOS1_master_not_null and ONOS2_master_not_null and\
+                ONOS3_master_not_null and ONOS4_master_not_null and\
+                ONOS5_master_not_null and ONOS6_master_not_null and\
+                ONOS7_master_not_null
+        utilities.assert_equals(expect = main.TRUE,actual=roles_not_null,
+                onpass="Each device has a master",
+                onfail="Some devices don't have a master assigned")
+
+
         ONOS1_mastership = main.ONOScli1.roles()
         ONOS2_mastership = main.ONOScli2.roles()
         ONOS3_mastership = main.ONOScli3.roles()
@@ -416,6 +650,7 @@
 
         main.step("Get the intents from each controller")
         global intent_state
+        intent_state = []
         ONOS1_intents = main.ONOScli1.intents( json_format=True )
         ONOS2_intents = main.ONOScli2.intents( json_format=True )
         ONOS3_intents = main.ONOScli3.intents( json_format=True )
@@ -470,6 +705,7 @@
 
         main.step("Get the flows from each controller")
         global flow_state
+        flow_state = []
         ONOS1_flows = main.ONOScli1.flows( json_format=True )
         ONOS2_flows = main.ONOScli2.flows( json_format=True )
         ONOS3_flows = main.ONOScli3.flows( json_format=True )
@@ -527,7 +763,7 @@
         global flows
         flows=[]
         for i in range(1,29):
-            flows.append(main.Mininet2.get_flowTable("s"+str(i),1.0))
+            flows.append(main.Mininet2.get_flowTable(1.3, "s"+str(i)))
 
         #TODO: Compare switch flow tables with ONOS flow tables
 
@@ -578,16 +814,18 @@
         devices.append( main.ONOScli5.devices() )
         devices.append( main.ONOScli6.devices() )
         devices.append( main.ONOScli7.devices() )
-        '''
         hosts = []
-        hosts.append( main.ONOScli1.hosts() )
-        hosts.append( main.ONOScli2.hosts() )
-        hosts.append( main.ONOScli3.hosts() )
-        hosts.append( main.ONOScli4.hosts() )
-        hosts.append( main.ONOScli5.hosts() )
-        hosts.append( main.ONOScli6.hosts() )
-        hosts.append( main.ONOScli7.hosts() )
-        '''
+        hosts.append( json.loads( main.ONOScli1.hosts() ) )
+        hosts.append( json.loads( main.ONOScli2.hosts() ) )
+        hosts.append( json.loads( main.ONOScli3.hosts() ) )
+        hosts.append( json.loads( main.ONOScli4.hosts() ) )
+        hosts.append( json.loads( main.ONOScli5.hosts() ) )
+        hosts.append( json.loads( main.ONOScli6.hosts() ) )
+        hosts.append( json.loads( main.ONOScli7.hosts() ) )
+        for controller in range(0, len(hosts) ):
+            for host in hosts[controller]:
+                if host['ips'] == []:
+                    main.log.error("DEBUG:Error with host ips on controller"+str(controller+1)+": " + str(host))
         ports = []
         ports.append( main.ONOScli1.ports() )
         ports.append( main.ONOScli2.ports() )
@@ -604,13 +842,98 @@
         links.append( main.ONOScli5.links() )
         links.append( main.ONOScli6.links() )
         links.append( main.ONOScli7.links() )
+        clusters = []
+        clusters.append( main.ONOScli1.clusters() )
+        clusters.append( main.ONOScli2.clusters() )
+        clusters.append( main.ONOScli3.clusters() )
+        clusters.append( main.ONOScli4.clusters() )
+        clusters.append( main.ONOScli5.clusters() )
+        clusters.append( main.ONOScli6.clusters() )
+        clusters.append( main.ONOScli7.clusters() )
+        paths = []
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli1.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli2.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli3.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli4.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli5.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli6.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli7.topology() )
+        paths.append( temp_topo.get('paths', False) )
+
+        #Compare json objects for hosts, dataplane clusters and paths
+
+        #hosts
+        consistent_hosts_result = main.TRUE
+        for controller in range( len( hosts ) ):
+            if not "Error" in hosts[controller]:
+                if hosts[controller] == hosts[0]:
+                    continue
+                else:#hosts not consistent
+                    main.log.report("hosts from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                    main.log.warn( repr( hosts[controller] ) )
+                    consistent_hosts_result = main.FALSE
+
+            else:
+                main.log.report("Error in getting ONOS hosts from ONOS" + str(controller + 1) )
+                consistent_hosts_result = main.FALSE
+                main.log.warn("ONOS" + str(controller + 1) + " hosts response: " + repr(hosts[controller]) )
+        utilities.assert_equals(expect = main.TRUE,actual=consistent_hosts_result,
+                onpass="Hosts view is consistent across all ONOS nodes",
+                onfail="ONOS nodes have different views of hosts")
+
+        #Strongly connected clusters of devices
+        consistent_clusters_result = main.TRUE
+        for controller in range( len( clusters ) ):
+            if not "Error" in clusters[controller]:
+                if clusters[controller] == clusters[0]:
+                    continue
+                else:#clusters not consistent
+                    main.log.report("clusters from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                    consistent_clusters_result = main.FALSE
+
+            else:
+                main.log.report("Error in getting dataplane clusters from ONOS" + str(controller + 1) )
+                consistent_clusters_result = main.FALSE
+                main.log.warn("ONOS" + str(controller + 1) + " clusters response: " + repr(clusters[controller]) )
+        utilities.assert_equals(expect = main.TRUE,actual=consistent_clusters_result,
+                onpass="Clusters view is consistent across all ONOS nodes",
+                onfail="ONOS nodes have different views of clusters")
+        num_clusters =  len(json.loads(clusters[0])) #there should always only be one cluster
+        utilities.assert_equals(expect = 1, actual = num_clusters,
+                onpass="ONOS shows 1 SCC",
+                onfail="ONOS shows "+str(num_clusters) +" SCCs")
+
+
+        #paths
+        consistent_paths_result = main.TRUE
+        for controller in range( len( paths ) ):
+            if not "Error" in paths[controller]:
+                if paths[controller] == paths[0]:
+                    continue
+                else:#paths not consistent
+                    main.log.report("paths from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                    consistent_paths_result = main.FALSE
+
+            else:
+                main.log.report("Error in getting paths from ONOS" + str(controller + 1) )
+                consistent_paths_result = main.FALSE
+                main.log.warn("ONOS" + str(controller + 1) + " paths response: " + repr(paths[controller]) )
+        utilities.assert_equals(expect = main.TRUE,actual=consistent_paths_result,
+                onpass="Paths count is consistent across all ONOS nodes",
+                onfail="ONOS nodes have different counts of paths")
 
 
         main.step("Comparing ONOS topology to MN")
         devices_results = main.TRUE
         ports_results = main.TRUE
         links_results = main.TRUE
-        for controller in range(7): #TODO parameterize the number of controllers
+        for controller in range(num_controllers):
             if devices[controller] or not "Error" in devices[controller]:
                 current_devices_result =  main.Mininet1.compare_switches(MNTopo, json.loads(devices[controller]))
             else:
@@ -639,14 +962,16 @@
             ports_results = ports_results and current_ports_result
             links_results = links_results and current_links_result
 
-        topo_result = devices_results and ports_results and links_results
+        topo_result = devices_results and ports_results and links_results\
+                and consistent_hosts_result and consistent_clusters_result\
+                and consistent_paths_result
         utilities.assert_equals(expect=main.TRUE, actual=topo_result,
                 onpass="Topology Check Test successful",
                 onfail="Topology Check Test NOT successful")
 
         final_assert = main.TRUE
         final_assert = final_assert and topo_result and flow_check \
-                and intent_check and consistent_mastership
+                and intent_check and consistent_mastership and roles_not_null
         utilities.assert_equals(expect=main.TRUE, actual=final_assert,
                 onpass="State check successful",
                 onfail="State check NOT successful")
@@ -656,11 +981,14 @@
         '''
         The Failure case.
         '''
+        import time
         main.log.report("Killing 3 ONOS nodes")
         main.log.case("Restart minority of ONOS nodes")
         #TODO: Randomize these nodes
         main.ONOSbench.onos_kill(ONOS1_ip)
+        time.sleep(10)
         main.ONOSbench.onos_kill(ONOS2_ip)
+        time.sleep(10)
         main.ONOSbench.onos_kill(ONOS3_ip)
 
         main.step("Checking if ONOS is up yet")
@@ -680,6 +1008,8 @@
         cli_result3 = main.ONOScli3.start_onos_cli(ONOS3_ip)
         cli_results = cli_result1 and cli_result2 and cli_result3
 
+        main.log.info("Install leadership election app on restarted node")
+
         case_results = main.TRUE and onos_isup_result and cli_results
         utilities.assert_equals(expect=main.TRUE, actual=case_results,
                 onpass="ONOS restart successful",
@@ -694,6 +1024,24 @@
         import json
         main.case("Running ONOS Constant State Tests")
 
+        #Assert that each device has a master
+        ONOS1_master_not_null = main.ONOScli1.roles_not_null()
+        ONOS2_master_not_null = main.ONOScli2.roles_not_null()
+        ONOS3_master_not_null = main.ONOScli3.roles_not_null()
+        ONOS4_master_not_null = main.ONOScli4.roles_not_null()
+        ONOS5_master_not_null = main.ONOScli5.roles_not_null()
+        ONOS6_master_not_null = main.ONOScli6.roles_not_null()
+        ONOS7_master_not_null = main.ONOScli7.roles_not_null()
+        roles_not_null = ONOS1_master_not_null and ONOS2_master_not_null and\
+                ONOS3_master_not_null and ONOS4_master_not_null and\
+                ONOS5_master_not_null and ONOS6_master_not_null and\
+                ONOS7_master_not_null
+        utilities.assert_equals(expect = main.TRUE,actual=roles_not_null,
+                onpass="Each device has a master",
+                onfail="Some devices don't have a master assigned")
+
+
+
         main.step("Check if switch roles are consistent across all nodes")
         ONOS1_mastership = main.ONOScli1.roles()
         ONOS2_mastership = main.ONOScli2.roles()
@@ -702,20 +1050,6 @@
         ONOS5_mastership = main.ONOScli5.roles()
         ONOS6_mastership = main.ONOScli6.roles()
         ONOS7_mastership = main.ONOScli7.roles()
-        print type(ONOS1_mastership)
-        print ONOS1_mastership
-        print type(ONOS2_mastership)
-        print ONOS2_mastership
-        print type(ONOS3_mastership)
-        print ONOS3_mastership
-        print type(ONOS4_mastership)
-        print ONOS4_mastership
-        print type(ONOS5_mastership)
-        print ONOS5_mastership
-        print type(ONOS6_mastership)
-        print ONOS6_mastership
-        print type(ONOS7_mastership)
-        print ONOS7_mastership
         #print json.dumps(json.loads(ONOS1_mastership), sort_keys=True, indent=4, separators=(',', ': '))
         if "Error" in ONOS1_mastership or not ONOS1_mastership\
                 or "Error" in ONOS2_mastership or not ONOS2_mastership\
@@ -739,7 +1073,6 @@
                 and ONOS1_mastership == ONOS5_mastership\
                 and ONOS1_mastership == ONOS6_mastership\
                 and ONOS1_mastership == ONOS7_mastership:
-                    #mastership_state = ONOS1_mastership
                     consistent_mastership = main.TRUE
                     main.log.report("Switch roles are consistent across all ONOS nodes")
         else:
@@ -785,7 +1118,7 @@
                 onpass="Mastership of Switches was not changed",
                 onfail="Mastership of some switches changed")
         #NOTE: we expect mastership to change on controller failure
-        mastership_check = mastership_check #and consistent_mastership
+        mastership_check = consistent_mastership
 
 
 
@@ -822,30 +1155,46 @@
                     intent_check = main.TRUE
                     main.log.report("Intents are consistent across all ONOS nodes")
         else:
-            main.log.warn("ONOS1 intents: ", json.dumps(json.loads(ONOS1_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS2 intents: ", json.dumps(json.loads(ONOS2_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS3 intents: ", json.dumps(json.loads(ONOS3_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS4 intents: ", json.dumps(json.loads(ONOS4_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS5 intents: ", json.dumps(json.loads(ONOS5_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS6 intents: ", json.dumps(json.loads(ONOS6_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS7 intents: ", json.dumps(json.loads(ONOS7_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
+            main.log.warn("ONOS1 intents: ")
+            print json.dumps(json.loads(ONOS1_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS2 intents: ")
+            print json.dumps(json.loads(ONOS2_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS3 intents: ")
+            print json.dumps(json.loads(ONOS3_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS4 intents: ")
+            print json.dumps(json.loads(ONOS4_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS5 intents: ")
+            print json.dumps(json.loads(ONOS5_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS6 intents: ")
+            print json.dumps(json.loads(ONOS6_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS7 intents: ")
+            print json.dumps(json.loads(ONOS7_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
         utilities.assert_equals(expect = main.TRUE,actual=intent_check,
                 onpass="Intents are consistent across all ONOS nodes",
                 onfail="ONOS nodes have different views of intents")
 
+        #NOTE: Hazelcast has no durability, so intents are lost across system restarts
         main.step("Compare current intents with intents before the failure")
+        #NOTE: this requires case 5 to pass for intent_state to be set.
+        #      maybe we should stop the test if that fails?
         if intent_state == ONOS1_intents:
             same_intents = main.TRUE
             main.log.report("Intents are consistent with before failure")
         #TODO: possibly the states have changed? we may need to figure out what the aceptable states are
         else:
+            try:
+                main.log.warn("ONOS1 intents: ")
+                print json.dumps(json.loads(ONOS1_intents),
+                    sort_keys=True, indent=4, separators=(',', ': '))
+            except:
+                pass
             same_intents = main.FALSE
         utilities.assert_equals(expect = main.TRUE,actual=same_intents,
                 onpass="Intents are consistent with before failure",
@@ -859,12 +1208,12 @@
         flows2=[]
         for i in range(28):
             main.log.info("Checking flow table on s" + str(i+1))
-            tmp_flows = main.Mininet2.get_flowTable("s"+str(i+1),1.0)
+            tmp_flows = main.Mininet2.get_flowTable(1.3, "s"+str(i+1))
             flows2.append(tmp_flows)
-            Flow_Tables = Flow_Tables and main.Mininet2.flow_comp(flow1=flows[i],flow2=tmp_flows)
+            temp_result = main.Mininet2.flow_comp(flow1=flows[i],flow2=tmp_flows)
+            Flow_Tables = Flow_Tables and temp_result
             if Flow_Tables == main.FALSE:
                 main.log.info("Differences in flow table for switch: "+str(i+1))
-                break
         if Flow_Tables == main.TRUE:
             main.log.report("No changes were found in the flow tables")
         utilities.assert_equals(expect=main.TRUE,actual=Flow_Tables,
@@ -880,7 +1229,7 @@
         #NOTE: checkForLoss returns main.FALSE with 0% packet loss
         for i in range(8,18):
             main.log.info("Checking for a loss in pings along flow from s" + str(i))
-            Loss_In_Pings = Loss_In_Pings or main.Mininet2.checkForLoss("/tmp/ping.h"+str(i))
+            Loss_In_Pings = main.Mininet2.checkForLoss("/tmp/ping.h"+str(i)) or Loss_In_Pings
         if Loss_In_Pings == main.TRUE:
             main.log.info("Loss in ping detected")
         elif Loss_In_Pings == main.ERROR:
@@ -893,8 +1242,36 @@
                 onfail="Loss of dataplane connectivity detected")
 
 
-        #TODO:add topology to this or leave as a seperate case?
-        result = mastership_check and intent_check and Flow_Tables and (not Loss_In_Pings)
+        #Test of LeadershipElection
+        leader_list = []
+        leader_result = main.TRUE
+        for controller in range(1,num_controllers+1):
+            node = getattr( main, ( 'ONOScli' + str( controller ) ) )#loop through ONOScli handlers
+            leaderN = node.election_test_leader()
+            leader_list.append(leaderN)
+            if leaderN == main.FALSE:
+                #error in  response
+                main.log.report("Something is wrong with election_test_leader function, check the error logs")
+                leader_result = main.FALSE
+            elif leaderN == None:
+                main.log.report("ONOS"+str(controller) + " shows no leader for the election-app was elected after the old one died")
+                leader_result = main.FALSE
+            elif leaderN == ONOS1_ip or leaderN == ONOS2_ip or leaderN == ONOS3_ip:
+                main.log.report("ONOS"+str(controller) + " shows "+str(leaderN)+" as leader for the election-app, but it was restarted")
+                leader_result = main.FALSE
+        if len( set( leader_list ) ) != 1:
+            leader_result = main.FALSE
+            main.log.error("Inconsistent view of leader for the election test app")
+            #TODO: print the list
+        if leader_result:
+            main.log.report("Leadership election tests passed(consistent view of leader across listeners and a new leader was re-elected if applicable)")
+        utilities.assert_equals(expect=main.TRUE, actual=leader_result,
+                onpass="Leadership election passed",
+                onfail="Something went wrong with Leadership election")
+
+
+        result = mastership_check and intent_check and Flow_Tables and (not Loss_In_Pings) and roles_not_null\
+                and leader_result
         result = int(result)
         if result == main.TRUE:
             main.log.report("Constant State Tests Passed")
@@ -936,87 +1313,180 @@
         ports_results = main.TRUE
         links_results = main.TRUE
         topo_result = main.FALSE
-        start_time = time.time()
         elapsed = 0
         count = 0
-        while topo_result == main.FALSE and elapsed < 120:
+        main.step("Collecting topology information from ONOS")
+        start_time = time.time()
+        while topo_result == main.FALSE and elapsed < 60:
             count = count + 1
-            try:
-                main.step("Collecting topology information from ONOS")
-                devices = []
-                devices.append( main.ONOScli1.devices() )
-                devices.append( main.ONOScli2.devices() )
-                devices.append( main.ONOScli3.devices() )
-                devices.append( main.ONOScli4.devices() )
-                devices.append( main.ONOScli5.devices() )
-                devices.append( main.ONOScli6.devices() )
-                devices.append( main.ONOScli7.devices() )
-                '''
-                hosts = []
-                hosts.append( main.ONOScli1.hosts() )
-                hosts.append( main.ONOScli2.hosts() )
-                hosts.append( main.ONOScli3.hosts() )
-                hosts.append( main.ONOScli4.hosts() )
-                hosts.append( main.ONOScli5.hosts() )
-                hosts.append( main.ONOScli6.hosts() )
-                hosts.append( main.ONOScli7.hosts() )
-                '''
-                ports = []
-                ports.append( main.ONOScli1.ports() )
-                ports.append( main.ONOScli2.ports() )
-                ports.append( main.ONOScli3.ports() )
-                ports.append( main.ONOScli4.ports() )
-                ports.append( main.ONOScli5.ports() )
-                ports.append( main.ONOScli6.ports() )
-                ports.append( main.ONOScli7.ports() )
-                links = []
-                links.append( main.ONOScli1.links() )
-                links.append( main.ONOScli2.links() )
-                links.append( main.ONOScli3.links() )
-                links.append( main.ONOScli4.links() )
-                links.append( main.ONOScli5.links() )
-                links.append( main.ONOScli6.links() )
-                links.append( main.ONOScli7.links() )
+            if count > 1:
+                MNTopo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
+            cli_start = time.time()
+            devices = []
+            devices.append( main.ONOScli1.devices() )
+            devices.append( main.ONOScli2.devices() )
+            devices.append( main.ONOScli3.devices() )
+            devices.append( main.ONOScli4.devices() )
+            devices.append( main.ONOScli5.devices() )
+            devices.append( main.ONOScli6.devices() )
+            devices.append( main.ONOScli7.devices() )
+            hosts = []
+            hosts.append( json.loads( main.ONOScli1.hosts() ) )
+            hosts.append( json.loads( main.ONOScli2.hosts() ) )
+            hosts.append( json.loads( main.ONOScli3.hosts() ) )
+            hosts.append( json.loads( main.ONOScli4.hosts() ) )
+            hosts.append( json.loads( main.ONOScli5.hosts() ) )
+            hosts.append( json.loads( main.ONOScli6.hosts() ) )
+            hosts.append( json.loads( main.ONOScli7.hosts() ) )
+            for controller in range(0, len(hosts) ):
+                for host in hosts[controller]:
+                    host
+                    if host['ips'] == []:
+                        main.log.error("DEBUG:Error with host ips on controller"+str(controller+1)+": " + str(host))
+            ports = []
+            ports.append( main.ONOScli1.ports() )
+            ports.append( main.ONOScli2.ports() )
+            ports.append( main.ONOScli3.ports() )
+            ports.append( main.ONOScli4.ports() )
+            ports.append( main.ONOScli5.ports() )
+            ports.append( main.ONOScli6.ports() )
+            ports.append( main.ONOScli7.ports() )
+            links = []
+            links.append( main.ONOScli1.links() )
+            links.append( main.ONOScli2.links() )
+            links.append( main.ONOScli3.links() )
+            links.append( main.ONOScli4.links() )
+            links.append( main.ONOScli5.links() )
+            links.append( main.ONOScli6.links() )
+            links.append( main.ONOScli7.links() )
+            clusters = []
+            clusters.append( main.ONOScli1.clusters() )
+            clusters.append( main.ONOScli2.clusters() )
+            clusters.append( main.ONOScli3.clusters() )
+            clusters.append( main.ONOScli4.clusters() )
+            clusters.append( main.ONOScli5.clusters() )
+            clusters.append( main.ONOScli6.clusters() )
+            clusters.append( main.ONOScli7.clusters() )
+            paths = []
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli1.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli2.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli3.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli4.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli5.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli6.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli7.topology() )
+            paths.append( temp_topo.get('paths', False) )
 
-                for controller in range(7): #TODO parameterize the number of controllers
-                    if devices[controller] or not "Error" in devices[controller]:
-                        current_devices_result =  main.Mininet1.compare_switches(MNTopo, json.loads(devices[controller]))
-                    else:
-                        current_devices_result = main.FALSE
-                    utilities.assert_equals(expect=main.TRUE, actual=current_devices_result,
-                            onpass="ONOS"+str(int(controller+1))+" Switches view is correct",
-                            onfail="ONOS"+str(int(controller+1))+" Switches view is incorrect")
 
-                    if ports[controller] or not "Error" in ports[controller]:
-                        current_ports_result =  main.Mininet1.compare_ports(MNTopo, json.loads(ports[controller]))
-                    else:
-                        current_ports_result = main.FALSE
-                    utilities.assert_equals(expect=main.TRUE, actual=current_ports_result,
-                            onpass="ONOS"+str(int(controller+1))+" ports view is correct",
-                            onfail="ONOS"+str(int(controller+1))+" ports view is incorrect")
+            elapsed = time.time() - start_time
+            cli_time = time.time() - cli_start
+            print "CLI time: " + str(cli_time)
 
-                    if links[controller] or not "Error" in links[controller]:
-                        current_links_result =  main.Mininet1.compare_links(MNTopo, json.loads(links[controller]))
-                    else:
-                        current_links_result = main.FALSE
-                    utilities.assert_equals(expect=main.TRUE, actual=current_links_result,
-                            onpass="ONOS"+str(int(controller+1))+" links view is correct",
-                            onfail="ONOS"+str(int(controller+1))+" links view is incorrect")
-            except:
-                main.log.error("something went wrong in topo comparison")
-                main.log.warn( repr( devices ) )
-                main.log.warn( repr( ports ) )
-                main.log.warn( repr( links ) )
+            for controller in range(num_controllers):
+                if devices[controller] or not "Error" in devices[controller]:
+                    current_devices_result =  main.Mininet1.compare_switches(MNTopo, json.loads(devices[controller]))
+                else:
+                    current_devices_result = main.FALSE
+                utilities.assert_equals(expect=main.TRUE, actual=current_devices_result,
+                        onpass="ONOS"+str(int(controller+1))+" Switches view is correct",
+                        onfail="ONOS"+str(int(controller+1))+" Switches view is incorrect")
 
+                if ports[controller] or not "Error" in ports[controller]:
+                    current_ports_result =  main.Mininet1.compare_ports(MNTopo, json.loads(ports[controller]))
+                else:
+                    current_ports_result = main.FALSE
+                utilities.assert_equals(expect=main.TRUE, actual=current_ports_result,
+                        onpass="ONOS"+str(int(controller+1))+" ports view is correct",
+                        onfail="ONOS"+str(int(controller+1))+" ports view is incorrect")
+
+                if links[controller] or not "Error" in links[controller]:
+                    current_links_result =  main.Mininet1.compare_links(MNTopo, json.loads(links[controller]))
+                else:
+                    current_links_result = main.FALSE
+                utilities.assert_equals(expect=main.TRUE, actual=current_links_result,
+                        onpass="ONOS"+str(int(controller+1))+" links view is correct",
+                        onfail="ONOS"+str(int(controller+1))+" links view is incorrect")
             devices_results = devices_results and current_devices_result
             ports_results = ports_results and current_ports_result
             links_results = links_results and current_links_result
-            topo_result = devices_results and ports_results and links_results
-            elapsed = time.time() - start_time
-        time_threshold = elapsed < 1
-        topo_result = topo_result and time_threshold
-        #TODO make sure this step is non-blocking. IE add a timeout
-        main.log.report("Very crass estimate for topology discovery/convergence: " +\
+
+            #Compare json objects for hosts, dataplane clusters and paths
+
+            #hosts
+            consistent_hosts_result = main.TRUE
+            for controller in range( len( hosts ) ):
+                if not "Error" in hosts[controller]:
+                    if hosts[controller] == hosts[0]:
+                        continue
+                    else:#hosts not consistent
+                        main.log.report("hosts from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                        main.log.warn( repr( hosts[controller] ) )
+                        consistent_hosts_result = main.FALSE
+
+                else:
+                    main.log.report("Error in getting ONOS hosts from ONOS" + str(controller + 1) )
+                    consistent_hosts_result = main.FALSE
+            if consistent_hosts_result == main.FALSE:
+                for controller in range( len( hosts ) ):
+                    main.log.warn("ONOS" + str(controller + 1) + " hosts response: " + repr(hosts[controller]) )
+            utilities.assert_equals(expect = main.TRUE,actual=consistent_hosts_result,
+                    onpass="Hosts view is consistent across all ONOS nodes",
+                    onfail="ONOS nodes have different views of hosts")
+
+            #Strongly connected clusters of devices
+            consistent_clusters_result = main.TRUE
+            for controller in range( len( clusters ) ):
+                if not "Error" in clusters[controller]:
+                    if clusters[controller] == clusters[0]:
+                        continue
+                    else:#clusters not consistent
+                        main.log.report("clusters from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                        consistent_clusters_result = main.FALSE
+
+                else:
+                    main.log.report("Error in getting dataplane clusters from ONOS" + str(controller + 1) )
+                    consistent_clusters_result = main.FALSE
+                    main.log.warn("ONOS" + str(controller + 1) + " clusters response: " + repr(clusters[controller]) )
+            utilities.assert_equals(expect = main.TRUE,actual=consistent_clusters_result,
+                    onpass="Clusters view is consistent across all ONOS nodes",
+                    onfail="ONOS nodes have different views of clusters")
+            num_clusters =  len(json.loads(clusters[0])) #there should always only be one cluster
+            utilities.assert_equals(expect = 1, actual = num_clusters,
+                    onpass="ONOS shows 1 SCC",
+                    onfail="ONOS shows "+str(num_clusters) +" SCCs")
+
+
+            #paths
+            consistent_paths_result = main.TRUE
+            for controller in range( len( paths ) ):
+                if not "Error" in paths[controller]:
+                    if paths[controller] == paths[0]:
+                        continue
+                    else:#paths not consistent
+                        main.log.report("paths from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                        consistent_paths_result = main.FALSE
+
+                else:
+                    main.log.report("Error in getting paths from ONOS" + str(controller + 1) )
+                    consistent_paths_result = main.FALSE
+                    main.log.warn("ONOS" + str(controller + 1) + " paths response: " + repr(paths[controller]) )
+            utilities.assert_equals(expect = main.TRUE,actual=consistent_paths_result,
+                    onpass="Paths count is consistent across all ONOS nodes",
+                    onfail="ONOS nodes have different counts of paths")
+
+
+            topo_result = devices_results and ports_results and links_results\
+                    and consistent_hosts_result and consistent_clusters_result and consistent_paths_result
+
+        topo_result = topo_result and int(count <= 2)
+        note = "note it takes about "+str( int(cli_time) )+" seconds for the test to make all the cli calls to fetch the topology from each ONOS instance"
+        main.log.report("Very crass estimate for topology discovery/convergence("+ str(note) + "): " +\
                 str(elapsed) + " seconds, " + str(count) +" tries" )
         utilities.assert_equals(expect=main.TRUE, actual=topo_result,
                 onpass="Topology Check Test successful",
@@ -1031,7 +1501,7 @@
         '''
         #NOTE: You should probably run a topology check after this
 
-        link_sleep = int(main.params['timers']['LinkDiscovery'])
+        link_sleep = float(main.params['timers']['LinkDiscovery'])
 
         description = "Turn off a link to ensure that Link Discovery is working properly"
         main.log.report(description)
@@ -1053,7 +1523,7 @@
         '''
         #NOTE: You should probably run a topology check after this
 
-        link_sleep = int(main.params['timers']['LinkDiscovery'])
+        link_sleep = float(main.params['timers']['LinkDiscovery'])
 
         description = "Restore a link to ensure that Link Discovery is working properly"
         main.log.report(description)
@@ -1076,7 +1546,7 @@
         #NOTE: You should probably run a topology check after this
         import time
 
-        switch_sleep = int(main.params['timers']['SwitchDiscovery'])
+        switch_sleep = float(main.params['timers']['SwitchDiscovery'])
 
         description = "Killing a switch to ensure it is discovered correctly"
         main.log.report(description)
@@ -1085,13 +1555,18 @@
         #TODO: Make this switch parameterizable
         main.step("Kill s28 ")
         main.log.report("Deleting s28")
-        #FIXME: use new dynamic topo functions
         main.Mininet1.del_switch("s28")
         main.log.info("Waiting " + str(switch_sleep) + " seconds for switch down to be discovered")
         time.sleep(switch_sleep)
+        device = main.ONOScli1.get_device(dpid="0028")
         #Peek at the deleted switch
-        main.log.warn(main.ONOScli1.get_device(dpid="0028"))
-        #TODO do some sort of check here
+        main.log.warn( str(device) )
+        result = main.FALSE
+        if device and device['available'] == False:
+            result = main.TRUE
+        utilities.assert_equals(expect=main.TRUE,actual=result,
+                onpass="Kill switch succesful",
+                onfail="Failed to kill switch?")
 
     def CASE12 (self, main) :
         '''
@@ -1099,7 +1574,8 @@
         '''
         #NOTE: You should probably run a topology check after this
         import time
-        #FIXME: use new dynamic topo functions
+
+        switch_sleep = float(main.params['timers']['SwitchDiscovery'])
         description = "Adding a switch to ensure it is discovered correctly"
         main.log.report(description)
         main.case(description)
@@ -1111,7 +1587,7 @@
         main.Mininet1.add_link('s28', 's3')
         main.Mininet1.add_link('s28', 's6')
         main.Mininet1.add_link('s28', 'h28')
-        main.Mininet1.assign_sw_controller(sw="28",count=7,
+        main.Mininet1.assign_sw_controller(sw="28",count=num_controllers,
                 ip1=ONOS1_ip,port1=ONOS1_port,
                 ip2=ONOS2_ip,port2=ONOS2_port,
                 ip3=ONOS3_ip,port3=ONOS3_port,
@@ -1121,9 +1597,15 @@
                 ip7=ONOS7_ip,port7=ONOS7_port)
         main.log.info("Waiting " + str(switch_sleep) + " seconds for switch up to be discovered")
         time.sleep(switch_sleep)
-        #Peek at the added switch
-        main.log.warn(main.ONOScli1.get_device(dpid="0028"))
-        #TODO do some sort of check here
+        device = main.ONOScli1.get_device(dpid="0028")
+        #Peek at the deleted switch
+        main.log.warn( str(device) )
+        result = main.FALSE
+        if device and device['available'] == True:
+            result = main.TRUE
+        utilities.assert_equals(expect=main.TRUE,actual=result,
+                onpass="add switch succesful",
+                onfail="Failed to add switch?")
 
     def CASE13 (self, main) :
         '''
@@ -1131,14 +1613,41 @@
         '''
         import os
         import time
+        #printing colors to terminal
+        colors = {}
+        colors['cyan']   = '\033[96m'
+        colors['purple'] = '\033[95m'
+        colors['blue']   = '\033[94m'
+        colors['green']  = '\033[92m'
+        colors['yellow'] = '\033[93m'
+        colors['red']    = '\033[91m'
+        colors['end']    = '\033[0m'
         description = "Test Cleanup"
         main.log.report(description)
         main.case(description)
         main.step("Killing tcpdumps")
         main.Mininet2.stop_tcpdump()
 
+        main.step("Checking ONOS Logs for errors")
+        print colors['purple'] + "Checking logs for errors on ONOS1:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS1_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS2:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS2_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS3:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS3_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS4:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS4_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS5:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS5_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS6:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS6_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS7:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS7_ip)
+
         main.step("Copying MN pcap and ONOS log files to test station")
         testname = main.TEST
+        teststation_user = main.params['TESTONUSER']
+        teststation_IP = main.params['TESTONIP']
         #NOTE: MN Pcap file is being saved to ~/packet_captures
         #       scp this file as MN and TestON aren't necessarily the same vm
         #FIXME: scp
@@ -1150,19 +1659,26 @@
         #NOTE: must end in /
         dst_dir = "~/packet_captures/"
         for f in log_files:
-            main.ONOSbench.secureCopy( "sdn", ONOS1_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS1_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS1-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS2_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS2_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS2-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS3_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS3_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS3-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS4_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS4_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS4-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS5_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS5_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS5-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS6_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS6_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS6-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS7_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS7_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS7-"+f )
 
         #std*.log's
@@ -1172,24 +1688,29 @@
         #NOTE: must end in /
         dst_dir = "~/packet_captures/"
         for f in log_files:
-            main.ONOSbench.secureCopy( "sdn", ONOS1_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS1_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS1-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS2_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS2_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS2-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS3_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS3_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS3-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS4_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS4_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS4-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS5_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS5_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS5-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS6_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS6_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS6-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS7_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS7_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS7-"+f )
 
 
-
-
         #sleep so scp can finish
         time.sleep(10)
         main.step("Packing and rotating pcap archives")
@@ -1200,3 +1721,139 @@
         utilities.assert_equals(expect=main.TRUE, actual=main.TRUE,
                 onpass="Test cleanup successful",
                 onfail="Test cleanup NOT successful")
+
+    def CASE14 ( self, main ) :
+        '''
+        start election app on all onos nodes
+        '''
+        leader_result = main.TRUE
+        #install app on onos 1
+        main.log.info("Install leadership election app")
+        main.ONOScli1.feature_install("onos-app-election")
+        #wait for election
+        #check for leader
+        leader = main.ONOScli1.election_test_leader()
+        #verify leader is ONOS1
+        if leader == ONOS1_ip:
+            #all is well
+            pass
+        elif leader == None:
+            #No leader elected
+            main.log.report("No leader was elected")
+            leader_result = main.FALSE
+        elif leader == main.FALSE:
+            #error in  response
+            #TODO: add check for "Command not found:" in the driver, this means the app isn't loaded
+            main.log.report("Something is wrong with election_test_leader function, check the error logs")
+            leader_result = main.FALSE
+        else:
+            #error in  response
+            main.log.report("Unexpected response from election_test_leader function:'"+str(leader)+"'")
+            leader_result = main.FALSE
+
+
+
+
+        #install on other nodes and check for leader.
+        #Should be onos1 and each app should show the same leader
+        for controller in range(2,num_controllers+1):
+            node = getattr( main, ( 'ONOScli' + str( controller ) ) )#loop through ONOScli handlers
+            node.feature_install("onos-app-election")
+            leaderN = node.election_test_leader()
+            #verify leader is ONOS1
+            if leaderN == ONOS1_ip:
+                #all is well
+                pass
+            elif leaderN == main.FALSE:
+                #error in  response
+                #TODO: add check for "Command not found:" in the driver, this means the app isn't loaded
+                main.log.report("Something is wrong with election_test_leader function, check the error logs")
+                leader_result = main.FALSE
+            elif leader != leaderN:
+                leader_result = main.FALSE
+                main.log.report("ONOS" + str(controller) + " sees "+str(leaderN) +
+                        " as the leader of the election app. Leader should be "+str(leader) )
+        if leader_result:
+            main.log.report("Leadership election tests passed(consistent view of leader across listeners and a leader was elected)")
+        utilities.assert_equals(expect=main.TRUE, actual=leader_result,
+                onpass="Leadership election passed",
+                onfail="Something went wrong with Leadership election")
+
+    def CASE15 ( self, main ) :
+        '''
+        Check that Leadership Election is still functional
+        '''
+        leader_result = main.TRUE
+        description = "Check that Leadership Election is still functional"
+        main.log.report(description)
+        main.case(description)
+        main.step("Find current leader and withdraw")
+        leader = main.ONOScli1.election_test_leader()
+        #TODO: do some sanity checking on leader before using it
+        withdraw_result = main.FALSE
+        if leader == ONOS1_ip:
+            old_leader = getattr( main, "ONOScli1" )
+        elif leader == ONOS2_ip:
+            old_leader = getattr( main, "ONOScli2" )
+        elif leader == ONOS3_ip:
+            old_leader = getattr( main, "ONOScli3" )
+        elif leader == ONOS4_ip:
+            old_leader = getattr( main, "ONOScli4" )
+        elif leader == ONOS5_ip:
+            old_leader = getattr( main, "ONOScli5" )
+        elif leader == ONOS6_ip:
+            old_leader = getattr( main, "ONOScli6" )
+        elif leader == ONOS7_ip:
+            old_leader = getattr( main, "ONOScli7" )
+        elif leader == None or leader == main.FALSE:
+            main.log.report("Leader for the election app should be an ONOS node,"\
+                    +"instead got '"+str(leader)+"'")
+            leader_result = main.FALSE
+        withdraw_result = old_leader.election_test_withdraw()
+
+
+        main.step("Make sure new leader is elected")
+        leader_list = []
+        for controller in range(1,num_controllers+1):
+            node = getattr( main, ( 'ONOScli' + str( controller ) ) )#loop through ONOScli handlers
+            leader_list.append( node.election_test_leader() )
+        for leaderN in leader_list:
+            if leaderN == leader:
+                main.log.report("ONOS"+str(controller)+" still sees " + str(leader) +\
+                        " as leader after they withdrew")
+                leader_result = main.FALSE
+            elif leaderN == main.FALSE:
+                #error in  response
+                #TODO: add check for "Command not found:" in the driver, this means the app isn't loaded
+                main.log.report("Something is wrong with election_test_leader function, check the error logs")
+                leader_result = main.FALSE
+        consistent_leader = main.FALSE
+        if len( set( leader_list ) ) == 1:
+            main.log.info("Each Election-app sees '"+str(leader_list[0])+"' as the leader")
+            consistent_leader = main.TRUE
+        else:
+            main.log.report("Inconsistent responses for leader of Election-app:")
+            for n in range(len(leader_list)):
+                main.log.report("ONOS" + str(n+1) + " response: " + str(leader_list[n]) )
+        if leader_result:
+            main.log.report("Leadership election tests passed(consistent view of leader across listeners and a new leader was elected when the old leader resigned)")
+        utilities.assert_equals(expect=main.TRUE, actual=leader_result,
+                onpass="Leadership election passed",
+                onfail="Something went wrong with Leadership election")
+
+
+        main.step("Run for election on old leader(just so everyone is in the hat)")
+        run_result = old_leader.election_test_run()
+        if consistent_leader == main.TRUE:
+            after_run = main.ONOScli1.election_test_leader()
+            #verify leader didn't just change
+            if after_run == leader_list[0]:
+                leader_result = main.TRUE
+            else:
+                leader_result = main.FALSE
+        #TODO: assert on  run and withdraw results?
+
+        utilities.assert_equals(expect=main.TRUE, actual=leader_result,
+                onpass="Leadership election passed",
+                onfail="Something went wrong with Leadership election after the old leader re-ran for election")
+
diff --git a/TestON/tests/HATestSanity/HATestSanity.params b/TestON/tests/HATestSanity/HATestSanity.params
index e1e75f9..78e0c83 100644
--- a/TestON/tests/HATestSanity/HATestSanity.params
+++ b/TestON/tests/HATestSanity/HATestSanity.params
@@ -1,9 +1,10 @@
 <PARAMS>
-    <testcases>1,2,8,3,4,5,[6],7,8,4,9,8,4,10,8,4,11,8,4,12,8,4,13</testcases>
+    <testcases>1,2,8,3,4,5,14,[6],8,7,4,15,9,8,4,10,8,4,11,8,4,12,8,4,13</testcases>
     <ENV>
     <cellName>HA</cellName>
     </ENV>
-    <Git>True</Git>
+    <Git>False</Git>
+    <num_controllers> 7 </num_controllers>
 
     <CTRL>
         <ip1>10.128.30.11</ip1>
@@ -28,7 +29,7 @@
         <port7>6633</port7>
     </CTRL>
     <TESTONUSER>admin</TESTONUSER>
-    <TESTONIP>10.128.30.10</TESTONIP>
+    <TESTONIP>10.128.30.9</TESTONIP>
     <PING>
         <source1>h8</source1>
         <source2>h9</source2>
@@ -52,8 +53,8 @@
         <target10>10.0.0.27</target10>
     </PING>
     <timers>
-        <LinkDiscovery>2</LinkDiscovery>
-        <SwitchDiscovery>2</SwitchDiscovery>
+        <LinkDiscovery>.2</LinkDiscovery>
+        <SwitchDiscovery>.2</SwitchDiscovery>
     </timers>
     <MNtcpdump>
         <intf>eth0</intf>
diff --git a/TestON/tests/HATestSanity/HATestSanity.py b/TestON/tests/HATestSanity/HATestSanity.py
index 614d514..2d56e90 100644
--- a/TestON/tests/HATestSanity/HATestSanity.py
+++ b/TestON/tests/HATestSanity/HATestSanity.py
@@ -17,6 +17,8 @@
 CASE11: Switch down
 CASE12: Switch up
 CASE13: Clean up
+CASE14: start election app on all onos nodes
+CASE15: Check that Leadership Election is still functional
 '''
 class HATestSanity:
 
@@ -63,6 +65,7 @@
         global ONOS6_port
         global ONOS7_ip
         global ONOS7_port
+        global num_controllers
 
         ONOS1_ip = main.params['CTRL']['ip1']
         ONOS1_port = main.params['CTRL']['port1']
@@ -78,6 +81,7 @@
         ONOS6_port = main.params['CTRL']['port6']
         ONOS7_ip = main.params['CTRL']['ip7']
         ONOS7_port = main.params['CTRL']['port7']
+        num_controllers = int(main.params['num_controllers'])
 
 
         main.step("Applying cell variable to environment")
@@ -101,6 +105,7 @@
 
         main.step("Compiling the latest version of ONOS")
         if PULL_CODE:
+            # Configure branch in params
             main.step("Git checkout and pull master")
             main.ONOSbench.git_checkout("master")
             git_pull_result = main.ONOSbench.git_pull()
@@ -145,8 +150,7 @@
 
 
         main.step("Checking if ONOS is up yet")
-        #TODO: Refactor
-        # check bundle:list?
+        #TODO check bundle:list?
         for i in range(2):
             onos1_isup = main.ONOSbench.isup(ONOS1_ip)
             if not onos1_isup:
@@ -173,7 +177,6 @@
                     and onos4_isup and onos5_isup and onos6_isup and onos7_isup
             if onos_isup_result == main.TRUE:
                 break
-        # TODO: if it becomes an issue, we can retry this step  a few times
 
 
         cli_result1 = main.ONOScli1.start_onos_cli(ONOS1_ip)
@@ -214,31 +217,12 @@
         import json
         import re
 
-
-        '''
-        ONOS1_ip = main.params['CTRL']['ip1']
-        ONOS1_port = main.params['CTRL']['port1']
-        ONOS2_ip = main.params['CTRL']['ip2']
-        ONOS2_port = main.params['CTRL']['port2']
-        ONOS3_ip = main.params['CTRL']['ip3']
-        ONOS3_port = main.params['CTRL']['port3']
-        ONOS4_ip = main.params['CTRL']['ip4']
-        ONOS4_port = main.params['CTRL']['port4']
-        ONOS5_ip = main.params['CTRL']['ip5']
-        ONOS5_port = main.params['CTRL']['port5']
-        ONOS6_ip = main.params['CTRL']['ip6']
-        ONOS6_port = main.params['CTRL']['port6']
-        ONOS7_ip = main.params['CTRL']['ip7']
-        ONOS7_port = main.params['CTRL']['port7']
-        '''
-
-
         main.log.report("Assigning switches to controllers")
         main.case("Assigning Controllers")
         main.step("Assign switches to controllers")
 
         for i in range (1,29):
-           main.Mininet1.assign_sw_controller(sw=str(i),count=7,
+           main.Mininet1.assign_sw_controller(sw=str(i),count=num_controllers,
                     ip1=ONOS1_ip,port1=ONOS1_port,
                     ip2=ONOS2_ip,port2=ONOS2_port,
                     ip3=ONOS3_ip,port3=ONOS3_port,
@@ -270,8 +254,217 @@
                 onpass="Switch mastership assigned correctly",
                 onfail="Switches not assigned correctly to controllers")
 
-        #TODO: If assign roles is working reliably then manually 
-        #   assign mastership to the controller we want
+        #Manually assign mastership to the controller we want
+        role_call = main.TRUE
+        role_check = main.TRUE
+
+        device_id = main.ONOScli1.get_device("1000")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS1_ip)
+        if ONOS1_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("2800")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS1_ip)
+        if ONOS1_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("2000")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS2_ip)
+        if ONOS2_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3000")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS2_ip)
+        if ONOS2_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("5000")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS3_ip)
+        if ONOS3_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6000")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS3_ip)
+        if ONOS3_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id =  main.ONOScli1.get_device("3004")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS4_ip)
+        if ONOS4_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3008")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3009")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3010")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3011")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3012")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3013")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3014")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3015")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3016")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("3017")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS5_ip)
+        if ONOS5_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6007")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS6_ip)
+        if ONOS6_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6018")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6019")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6020")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6021")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6022")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6023")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6024")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6025")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6026")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        device_id = main.ONOScli1.get_device("6027")['id']
+        role_call = role_call and main.ONOScli1.device_role(device_id, ONOS7_ip)
+        if ONOS7_ip in main.ONOScli1.get_role(device_id)['master']:
+            role_check = role_check and main.TRUE
+        else:
+            role_check = role_check and main.FALSE
+
+        utilities.assert_equals(expect = main.TRUE,actual=role_call,
+                onpass="Re-assigned switch mastership to designated controller",
+                onfail="Something wrong with device_role calls")
+
+        utilities.assert_equals(expect = main.TRUE,actual=role_check,
+                onpass="Switches were successfully reassigned to designated controller",
+                onfail="Switches were not successfully reassigned")
+        mastership_check = mastership_check and role_call and role_check
+        utilities.assert_equals(expect = main.TRUE,actual=mastership_check,
+                onpass="Switch mastership correctly assigned",
+                onfail="Error in (re)assigning switch mastership")
 
 
     def CASE3(self,main) :
@@ -288,6 +481,16 @@
         main.step("Discovering  Hosts( Via pingall for now)")
         #FIXME: Once we have a host discovery mechanism, use that instead
 
+        #install onos-app-fwd
+        main.log.info("Install reactive forwarding app")
+        main.ONOScli1.feature_install("onos-app-fwd")
+        main.ONOScli2.feature_install("onos-app-fwd")
+        main.ONOScli3.feature_install("onos-app-fwd")
+        main.ONOScli4.feature_install("onos-app-fwd")
+        main.ONOScli5.feature_install("onos-app-fwd")
+        main.ONOScli6.feature_install("onos-app-fwd")
+        main.ONOScli7.feature_install("onos-app-fwd")
+
         #REACTIVE FWD test
         ping_result = main.FALSE
         time1 = time.time()
@@ -304,22 +507,30 @@
         main.ONOScli5.feature_uninstall("onos-app-fwd")
         main.ONOScli6.feature_uninstall("onos-app-fwd")
         main.ONOScli7.feature_uninstall("onos-app-fwd")
+        #timeout for fwd flows
+        time.sleep(10)
 
         main.step("Add  host intents")
         #TODO:  move the host numbers to params
         import json
         intents_json= json.loads(main.ONOScli1.hosts())
-        intent_add_result = main.FALSE
+        intent_add_result = True
         for i in range(8,18):
             main.log.info("Adding host intent between h"+str(i)+" and h"+str(i+10))
             host1 =  "00:00:00:00:00:" + str(hex(i)[2:]).zfill(2).upper()
             host2 =  "00:00:00:00:00:" + str(hex(i+10)[2:]).zfill(2).upper()
-            #NOTE: get host can return None
-            #TODO: handle this
             host1_id = main.ONOScli1.get_host(host1)['id']
             host2_id = main.ONOScli1.get_host(host2)['id']
-            tmp_result = main.ONOScli1.add_host_intent(host1_id, host2_id )
-            intent_add_result = intent_add_result and tmp_result
+            #NOTE: get host can return None
+            if host1_id and host2_id:
+                tmp_result = main.ONOScli1.add_host_intent(host1_id, host2_id )
+            else:
+                main.log.error("Error, get_host() failed")
+                tmp_result = main.FALSE
+            intent_add_result = bool(intent_add_result and tmp_result)
+        utilities.assert_equals(expect=True, actual=intent_add_result,
+                onpass="Switch mastership correctly assigned",
+                onfail="Error in (re)assigning switch mastership")
         #TODO Check if intents all exist in datastore
         #NOTE: Do we need to print this once the test is working?
         #main.log.info(json.dumps(json.loads(main.ONOScli1.intents(json_format=True)),
@@ -365,6 +576,25 @@
 
         main.step("Get the Mastership of each switch from each controller")
         global mastership_state
+        mastership_state = []
+
+        #Assert that each device has a master
+        ONOS1_master_not_null = main.ONOScli1.roles_not_null()
+        ONOS2_master_not_null = main.ONOScli2.roles_not_null()
+        ONOS3_master_not_null = main.ONOScli3.roles_not_null()
+        ONOS4_master_not_null = main.ONOScli4.roles_not_null()
+        ONOS5_master_not_null = main.ONOScli5.roles_not_null()
+        ONOS6_master_not_null = main.ONOScli6.roles_not_null()
+        ONOS7_master_not_null = main.ONOScli7.roles_not_null()
+        roles_not_null = ONOS1_master_not_null and ONOS2_master_not_null and\
+                ONOS3_master_not_null and ONOS4_master_not_null and\
+                ONOS5_master_not_null and ONOS6_master_not_null and\
+                ONOS7_master_not_null
+        utilities.assert_equals(expect = main.TRUE,actual=roles_not_null,
+                onpass="Each device has a master",
+                onfail="Some devices don't have a master assigned")
+
+
         ONOS1_mastership = main.ONOScli1.roles()
         ONOS2_mastership = main.ONOScli2.roles()
         ONOS3_mastership = main.ONOScli3.roles()
@@ -421,6 +651,7 @@
 
         main.step("Get the intents from each controller")
         global intent_state
+        intent_state = []
         ONOS1_intents = main.ONOScli1.intents( json_format=True )
         ONOS2_intents = main.ONOScli2.intents( json_format=True )
         ONOS3_intents = main.ONOScli3.intents( json_format=True )
@@ -475,6 +706,7 @@
 
         main.step("Get the flows from each controller")
         global flow_state
+        flow_state = []
         ONOS1_flows = main.ONOScli1.flows( json_format=True )
         ONOS2_flows = main.ONOScli2.flows( json_format=True )
         ONOS3_flows = main.ONOScli3.flows( json_format=True )
@@ -532,7 +764,7 @@
         global flows
         flows=[]
         for i in range(1,29):
-            flows.append(main.Mininet2.get_flowTable("s"+str(i),1.0))
+            flows.append(main.Mininet2.get_flowTable(1.3, "s"+str(i)))
 
         #TODO: Compare switch flow tables with ONOS flow tables
 
@@ -583,7 +815,6 @@
         devices.append( main.ONOScli5.devices() )
         devices.append( main.ONOScli6.devices() )
         devices.append( main.ONOScli7.devices() )
-        '''
         hosts = []
         hosts.append( main.ONOScli1.hosts() )
         hosts.append( main.ONOScli2.hosts() )
@@ -592,7 +823,6 @@
         hosts.append( main.ONOScli5.hosts() )
         hosts.append( main.ONOScli6.hosts() )
         hosts.append( main.ONOScli7.hosts() )
-        '''
         ports = []
         ports.append( main.ONOScli1.ports() )
         ports.append( main.ONOScli2.ports() )
@@ -609,13 +839,98 @@
         links.append( main.ONOScli5.links() )
         links.append( main.ONOScli6.links() )
         links.append( main.ONOScli7.links() )
+        clusters = []
+        clusters.append( main.ONOScli1.clusters() )
+        clusters.append( main.ONOScli2.clusters() )
+        clusters.append( main.ONOScli3.clusters() )
+        clusters.append( main.ONOScli4.clusters() )
+        clusters.append( main.ONOScli5.clusters() )
+        clusters.append( main.ONOScli6.clusters() )
+        clusters.append( main.ONOScli7.clusters() )
+        paths = []
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli1.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli2.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli3.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli4.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli5.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli6.topology() )
+        paths.append( temp_topo.get('paths', False) )
+        temp_topo = main.ONOSbench.get_topology( main.ONOScli7.topology() )
+        paths.append( temp_topo.get('paths', False) )
+
+        #Compare json objects for hosts, dataplane clusters and paths
+
+        #hosts
+        consistent_hosts_result = main.TRUE
+        for controller in range( len( hosts ) ):
+            if not "Error" in hosts[controller]:
+                if hosts[controller] == hosts[0]:
+                    continue
+                else:#hosts not consistent
+                    main.log.report("hosts from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                    main.log.warn( repr( hosts[controller] ) )
+                    consistent_hosts_result = main.FALSE
+
+            else:
+                main.log.report("Error in getting ONOS hosts from ONOS" + str(controller + 1) )
+                consistent_hosts_result = main.FALSE
+                main.log.warn("ONOS" + str(controller + 1) + " hosts response: " + repr(hosts[controller]) )
+        utilities.assert_equals(expect = main.TRUE,actual=consistent_hosts_result,
+                onpass="Hosts view is consistent across all ONOS nodes",
+                onfail="ONOS nodes have different views of hosts")
+
+        #Strongly connected clusters of devices
+        consistent_clusters_result = main.TRUE
+        for controller in range( len( clusters ) ):
+            if not "Error" in clusters[controller]:
+                if clusters[controller] == clusters[0]:
+                    continue
+                else:#clusters not consistent
+                    main.log.report("clusters from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                    consistent_clusters_result = main.FALSE
+
+            else:
+                main.log.report("Error in getting dataplane clusters from ONOS" + str(controller + 1) )
+                consistent_clusters_result = main.FALSE
+                main.log.warn("ONOS" + str(controller + 1) + " clusters response: " + repr(clusters[controller]) )
+        utilities.assert_equals(expect = main.TRUE,actual=consistent_clusters_result,
+                onpass="Clusters view is consistent across all ONOS nodes",
+                onfail="ONOS nodes have different views of clusters")
+        num_clusters =  len(json.loads(clusters[0])) #there should always only be one cluster
+        utilities.assert_equals(expect = 1, actual = num_clusters,
+                onpass="ONOS shows 1 SCC",
+                onfail="ONOS shows "+str(num_clusters) +" SCCs")
+
+
+        #paths
+        consistent_paths_result = main.TRUE
+        for controller in range( len( paths ) ):
+            if not "Error" in paths[controller]:
+                if paths[controller] == paths[0]:
+                    continue
+                else:#paths not consistent
+                    main.log.report("paths from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                    consistent_paths_result = main.FALSE
+
+            else:
+                main.log.report("Error in getting paths from ONOS" + str(controller + 1) )
+                consistent_paths_result = main.FALSE
+                main.log.warn("ONOS" + str(controller + 1) + " paths response: " + repr(paths[controller]) )
+        utilities.assert_equals(expect = main.TRUE,actual=consistent_paths_result,
+                onpass="Paths count is consistent across all ONOS nodes",
+                onfail="ONOS nodes have different counts of paths")
 
 
         main.step("Comparing ONOS topology to MN")
         devices_results = main.TRUE
         ports_results = main.TRUE
         links_results = main.TRUE
-        for controller in range(7): #TODO parameterize the number of controllers
+        for controller in range(num_controllers):
             if devices[controller] or not "Error" in devices[controller]:
                 current_devices_result =  main.Mininet1.compare_switches(MNTopo, json.loads(devices[controller]))
             else:
@@ -644,14 +959,16 @@
             ports_results = ports_results and current_ports_result
             links_results = links_results and current_links_result
 
-        topo_result = devices_results and ports_results and links_results
+        topo_result = devices_results and ports_results and links_results\
+                and consistent_hosts_result and consistent_clusters_result\
+                and consistent_paths_result
         utilities.assert_equals(expect=main.TRUE, actual=topo_result,
                 onpass="Topology Check Test successful",
                 onfail="Topology Check Test NOT successful")
 
         final_assert = main.TRUE
         final_assert = final_assert and topo_result and flow_check \
-                and intent_check and consistent_mastership
+                and intent_check and consistent_mastership and roles_not_null
         utilities.assert_equals(expect=main.TRUE, actual=final_assert,
                 onpass="State check successful",
                 onfail="State check NOT successful")
@@ -676,6 +993,24 @@
         import json
         main.case("Running ONOS Constant State Tests")
 
+        #Assert that each device has a master
+        ONOS1_master_not_null = main.ONOScli1.roles_not_null()
+        ONOS2_master_not_null = main.ONOScli2.roles_not_null()
+        ONOS3_master_not_null = main.ONOScli3.roles_not_null()
+        ONOS4_master_not_null = main.ONOScli4.roles_not_null()
+        ONOS5_master_not_null = main.ONOScli5.roles_not_null()
+        ONOS6_master_not_null = main.ONOScli6.roles_not_null()
+        ONOS7_master_not_null = main.ONOScli7.roles_not_null()
+        roles_not_null = ONOS1_master_not_null and ONOS2_master_not_null and\
+                ONOS3_master_not_null and ONOS4_master_not_null and\
+                ONOS5_master_not_null and ONOS6_master_not_null and\
+                ONOS7_master_not_null
+        utilities.assert_equals(expect = main.TRUE,actual=roles_not_null,
+                onpass="Each device has a master",
+                onfail="Some devices don't have a master assigned")
+
+
+
         main.step("Check if switch roles are consistent across all nodes")
         ONOS1_mastership = main.ONOScli1.roles()
         ONOS2_mastership = main.ONOScli2.roles()
@@ -707,7 +1042,6 @@
                 and ONOS1_mastership == ONOS5_mastership\
                 and ONOS1_mastership == ONOS6_mastership\
                 and ONOS1_mastership == ONOS7_mastership:
-                    #mastership_state = ONOS1_mastership
                     consistent_mastership = main.TRUE
                     main.log.report("Switch roles are consistent across all ONOS nodes")
         else:
@@ -789,25 +1123,35 @@
                     intent_check = main.TRUE
                     main.log.report("Intents are consistent across all ONOS nodes")
         else:
-            main.log.warn("ONOS1 intents: ", json.dumps(json.loads(ONOS1_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS2 intents: ", json.dumps(json.loads(ONOS2_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS3 intents: ", json.dumps(json.loads(ONOS3_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS4 intents: ", json.dumps(json.loads(ONOS4_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS5 intents: ", json.dumps(json.loads(ONOS5_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS6 intents: ", json.dumps(json.loads(ONOS6_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
-            main.log.warn("ONOS7 intents: ", json.dumps(json.loads(ONOS7_intents),
-                sort_keys=True, indent=4, separators=(',', ': ')))
+            main.log.warn("ONOS1 intents: ") 
+            print json.dumps(json.loads(ONOS1_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS2 intents: ")
+            print json.dumps(json.loads(ONOS2_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS3 intents: ")
+            print json.dumps(json.loads(ONOS3_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS4 intents: ")
+            print json.dumps(json.loads(ONOS4_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS5 intents: ")
+            print json.dumps(json.loads(ONOS5_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS6 intents: ")
+            print json.dumps(json.loads(ONOS6_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
+            main.log.warn("ONOS7 intents: ")
+            print json.dumps(json.loads(ONOS7_intents),
+                sort_keys=True, indent=4, separators=(',', ': '))
         utilities.assert_equals(expect = main.TRUE,actual=intent_check,
                 onpass="Intents are consistent across all ONOS nodes",
                 onfail="ONOS nodes have different views of intents")
 
+        #NOTE: Hazelcast has no durability, so intents are lost
         main.step("Compare current intents with intents before the failure")
+        #NOTE: this requires case 5 to pass for intent_state to be set.
+        #      maybe we should stop the test if that fails?
         if intent_state == ONOS1_intents:
             same_intents = main.TRUE
             main.log.report("Intents are consistent with before failure")
@@ -826,12 +1170,12 @@
         flows2=[]
         for i in range(28):
             main.log.info("Checking flow table on s" + str(i+1))
-            tmp_flows = main.Mininet2.get_flowTable("s"+str(i+1),1.0)
+            tmp_flows = main.Mininet2.get_flowTable(1.3, "s"+str(i+1))
             flows2.append(tmp_flows)
-            Flow_Tables = Flow_Tables and main.Mininet2.flow_comp(flow1=flows[i],flow2=tmp_flows)
+            temp_result = main.Mininet2.flow_comp(flow1=flows[i],flow2=tmp_flows)
+            Flow_Tables = Flow_Tables and temp_result
             if Flow_Tables == main.FALSE:
                 main.log.info("Differences in flow table for switch: "+str(i+1))
-                break
         if Flow_Tables == main.TRUE:
             main.log.report("No changes were found in the flow tables")
         utilities.assert_equals(expect=main.TRUE,actual=Flow_Tables,
@@ -847,7 +1191,7 @@
         #NOTE: checkForLoss returns main.FALSE with 0% packet loss
         for i in range(8,18):
             main.log.info("Checking for a loss in pings along flow from s" + str(i))
-            Loss_In_Pings = Loss_In_Pings or main.Mininet2.checkForLoss("/tmp/ping.h"+str(i))
+            Loss_In_Pings = main.Mininet2.checkForLoss("/tmp/ping.h"+str(i)) or Loss_In_Pings
         if Loss_In_Pings == main.TRUE:
             main.log.info("Loss in ping detected")
         elif Loss_In_Pings == main.ERROR:
@@ -859,9 +1203,35 @@
                 onpass="No Loss of connectivity",
                 onfail="Loss of dataplane connectivity detected")
 
+        #Test of LeadershipElection
+        #NOTE: this only works for the sanity test. In case of failures, leader will likely change
+        leader = ONOS1_ip
+        leader_result = main.TRUE
+        for controller in range(1,num_controllers+1):
+            node = getattr( main, ( 'ONOScli' + str( controller ) ) )#loop through ONOScli handlers
+            leaderN = node.election_test_leader()
+            #verify leader is ONOS1
+            if leaderN == leader:
+                #all is well
+                #NOTE: In failure scenario, this could be a new node, maybe check != ONOS1
+                pass
+            elif leaderN == main.FALSE:
+                #error in  response
+                main.log.report("Something is wrong with election_test_leader function, check the error logs")
+                leader_result = main.FALSE
+            elif leader != leaderN:
+                leader_result = main.FALSE
+                main.log.report("ONOS" + str(controller) + " sees "+str(leaderN) +
+                        " as the leader of the election app. Leader should be "+str(leader) )
+        if leader_result:
+            main.log.report("Leadership election tests passed(consistent view of leader across listeners and a new leader was re-elected if applicable)")
+        utilities.assert_equals(expect=main.TRUE, actual=leader_result,
+                onpass="Leadership election passed",
+                onfail="Something went wrong with Leadership election")
 
-        #TODO:add topology to this or leave as a seperate case?
-        result = mastership_check and intent_check and Flow_Tables and (not Loss_In_Pings)
+
+        result = mastership_check and intent_check and Flow_Tables and (not Loss_In_Pings) and roles_not_null\
+                and leader_result
         result = int(result)
         if result == main.TRUE:
             main.log.report("Constant State Tests Passed")
@@ -903,89 +1273,173 @@
         ports_results = main.TRUE
         links_results = main.TRUE
         topo_result = main.FALSE
-        start_time = time.time()
         elapsed = 0
         count = 0
-        while topo_result == main.FALSE and elapsed < 120:
-            print "cond 1:" + str(topo_result == main.FALSE)
-            print "cond 2:" + str(elapsed < 120)
+        main.step("Collecting topology information from ONOS")
+        start_time = time.time()
+        while topo_result == main.FALSE and elapsed < 60:
             count = count + 1
-            try:
-                main.step("Collecting topology information from ONOS")
-                devices = []
-                devices.append( main.ONOScli1.devices() )
-                devices.append( main.ONOScli2.devices() )
-                devices.append( main.ONOScli3.devices() )
-                devices.append( main.ONOScli4.devices() )
-                devices.append( main.ONOScli5.devices() )
-                devices.append( main.ONOScli6.devices() )
-                devices.append( main.ONOScli7.devices() )
-                '''
-                hosts = []
-                hosts.append( main.ONOScli1.hosts() )
-                hosts.append( main.ONOScli2.hosts() )
-                hosts.append( main.ONOScli3.hosts() )
-                hosts.append( main.ONOScli4.hosts() )
-                hosts.append( main.ONOScli5.hosts() )
-                hosts.append( main.ONOScli6.hosts() )
-                hosts.append( main.ONOScli7.hosts() )
-                '''
-                ports = []
-                ports.append( main.ONOScli1.ports() )
-                ports.append( main.ONOScli2.ports() )
-                ports.append( main.ONOScli3.ports() )
-                ports.append( main.ONOScli4.ports() )
-                ports.append( main.ONOScli5.ports() )
-                ports.append( main.ONOScli6.ports() )
-                ports.append( main.ONOScli7.ports() )
-                links = []
-                links.append( main.ONOScli1.links() )
-                links.append( main.ONOScli2.links() )
-                links.append( main.ONOScli3.links() )
-                links.append( main.ONOScli4.links() )
-                links.append( main.ONOScli5.links() )
-                links.append( main.ONOScli6.links() )
-                links.append( main.ONOScli7.links() )
+            if count > 1:
+                MNTopo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
+            cli_start = time.time()
+            devices = []
+            devices.append( main.ONOScli1.devices() )
+            devices.append( main.ONOScli2.devices() )
+            devices.append( main.ONOScli3.devices() )
+            devices.append( main.ONOScli4.devices() )
+            devices.append( main.ONOScli5.devices() )
+            devices.append( main.ONOScli6.devices() )
+            devices.append( main.ONOScli7.devices() )
+            hosts = []
+            hosts.append( main.ONOScli1.hosts() )
+            hosts.append( main.ONOScli2.hosts() )
+            hosts.append( main.ONOScli3.hosts() )
+            hosts.append( main.ONOScli4.hosts() )
+            hosts.append( main.ONOScli5.hosts() )
+            hosts.append( main.ONOScli6.hosts() )
+            hosts.append( main.ONOScli7.hosts() )
+            ports = []
+            ports.append( main.ONOScli1.ports() )
+            ports.append( main.ONOScli2.ports() )
+            ports.append( main.ONOScli3.ports() )
+            ports.append( main.ONOScli4.ports() )
+            ports.append( main.ONOScli5.ports() )
+            ports.append( main.ONOScli6.ports() )
+            ports.append( main.ONOScli7.ports() )
+            links = []
+            links.append( main.ONOScli1.links() )
+            links.append( main.ONOScli2.links() )
+            links.append( main.ONOScli3.links() )
+            links.append( main.ONOScli4.links() )
+            links.append( main.ONOScli5.links() )
+            links.append( main.ONOScli6.links() )
+            links.append( main.ONOScli7.links() )
+            clusters = []
+            clusters.append( main.ONOScli1.clusters() )
+            clusters.append( main.ONOScli2.clusters() )
+            clusters.append( main.ONOScli3.clusters() )
+            clusters.append( main.ONOScli4.clusters() )
+            clusters.append( main.ONOScli5.clusters() )
+            clusters.append( main.ONOScli6.clusters() )
+            clusters.append( main.ONOScli7.clusters() )
+            paths = []
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli1.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli2.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli3.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli4.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli5.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli6.topology() )
+            paths.append( temp_topo.get('paths', False) )
+            temp_topo = main.ONOSbench.get_topology( main.ONOScli7.topology() )
+            paths.append( temp_topo.get('paths', False) )
 
-                for controller in range(7): #TODO parameterize the number of controllers
-                    if devices[controller] or not "Error" in devices[controller]:
-                        current_devices_result =  main.Mininet1.compare_switches(MNTopo, json.loads(devices[controller]))
-                    else:
-                        current_devices_result = main.FALSE
-                    utilities.assert_equals(expect=main.TRUE, actual=current_devices_result,
-                            onpass="ONOS"+str(int(controller+1))+" Switches view is correct",
-                            onfail="ONOS"+str(int(controller+1))+" Switches view is incorrect")
 
-                    if ports[controller] or not "Error" in ports[controller]:
-                        current_ports_result =  main.Mininet1.compare_ports(MNTopo, json.loads(ports[controller]))
-                    else:
-                        current_ports_result = main.FALSE
-                    utilities.assert_equals(expect=main.TRUE, actual=current_ports_result,
-                            onpass="ONOS"+str(int(controller+1))+" ports view is correct",
-                            onfail="ONOS"+str(int(controller+1))+" ports view is incorrect")
+            elapsed = time.time() - start_time
+            cli_time = time.time() - cli_start
+            print "CLI time: " + str(cli_time)
 
-                    if links[controller] or not "Error" in links[controller]:
-                        current_links_result =  main.Mininet1.compare_links(MNTopo, json.loads(links[controller]))
-                    else:
-                        current_links_result = main.FALSE
-                    utilities.assert_equals(expect=main.TRUE, actual=current_links_result,
-                            onpass="ONOS"+str(int(controller+1))+" links view is correct",
-                            onfail="ONOS"+str(int(controller+1))+" links view is incorrect")
-            except:
-                main.log.error("something went wrong in topo comparison")
-                main.log.warn( repr( devices ) )
-                main.log.warn( repr( ports ) )
-                main.log.warn( repr( links ) )
+            for controller in range(num_controllers):
+                if devices[controller] or not "Error" in devices[controller]:
+                    current_devices_result =  main.Mininet1.compare_switches(MNTopo, json.loads(devices[controller]))
+                else:
+                    current_devices_result = main.FALSE
+                utilities.assert_equals(expect=main.TRUE, actual=current_devices_result,
+                        onpass="ONOS"+str(int(controller+1))+" Switches view is correct",
+                        onfail="ONOS"+str(int(controller+1))+" Switches view is incorrect")
 
+                if ports[controller] or not "Error" in ports[controller]:
+                    current_ports_result =  main.Mininet1.compare_ports(MNTopo, json.loads(ports[controller]))
+                else:
+                    current_ports_result = main.FALSE
+                utilities.assert_equals(expect=main.TRUE, actual=current_ports_result,
+                        onpass="ONOS"+str(int(controller+1))+" ports view is correct",
+                        onfail="ONOS"+str(int(controller+1))+" ports view is incorrect")
+
+                if links[controller] or not "Error" in links[controller]:
+                    current_links_result =  main.Mininet1.compare_links(MNTopo, json.loads(links[controller]))
+                else:
+                    current_links_result = main.FALSE
+                utilities.assert_equals(expect=main.TRUE, actual=current_links_result,
+                        onpass="ONOS"+str(int(controller+1))+" links view is correct",
+                        onfail="ONOS"+str(int(controller+1))+" links view is incorrect")
             devices_results = devices_results and current_devices_result
             ports_results = ports_results and current_ports_result
             links_results = links_results and current_links_result
-            topo_result = devices_results and ports_results and links_results
-            elapsed = time.time() - start_time
-        time_threshold = elapsed < 1
-        topo_result = topo_result and time_threshold
-        #TODO make sure this step is non-blocking. IE add a timeout
-        main.log.report("Very crass estimate for topology discovery/convergence: " +\
+
+            #Compare json objects for hosts, dataplane clusters and paths
+
+            #hosts
+            consistent_hosts_result = main.TRUE
+            for controller in range( len( hosts ) ):
+                if not "Error" in hosts[controller]:
+                    if hosts[controller] == hosts[0]:
+                        continue
+                    else:#hosts not consistent
+                        main.log.report("hosts from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                        main.log.warn( repr( hosts[controller] ) )
+                        consistent_hosts_result = main.FALSE
+
+                else:
+                    main.log.report("Error in getting ONOS hosts from ONOS" + str(controller + 1) )
+                    consistent_hosts_result = main.FALSE
+                    main.log.warn("ONOS" + str(controller + 1) + " hosts response: " + repr(hosts[controller]) )
+            utilities.assert_equals(expect = main.TRUE,actual=consistent_hosts_result,
+                    onpass="Hosts view is consistent across all ONOS nodes",
+                    onfail="ONOS nodes have different views of hosts")
+
+            #Strongly connected clusters of devices
+            consistent_clusters_result = main.TRUE
+            for controller in range( len( clusters ) ):
+                if not "Error" in clusters[controller]:
+                    if clusters[controller] == clusters[0]:
+                        continue
+                    else:#clusters not consistent
+                        main.log.report("clusters from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                        consistent_clusters_result = main.FALSE
+
+                else:
+                    main.log.report("Error in getting dataplane clusters from ONOS" + str(controller + 1) )
+                    consistent_clusters_result = main.FALSE
+                    main.log.warn("ONOS" + str(controller + 1) + " clusters response: " + repr(clusters[controller]) )
+            utilities.assert_equals(expect = main.TRUE,actual=consistent_clusters_result,
+                    onpass="Clusters view is consistent across all ONOS nodes",
+                    onfail="ONOS nodes have different views of clusters")
+            num_clusters =  len(json.loads(clusters[0])) #there should always only be one cluster
+            utilities.assert_equals(expect = 1, actual = num_clusters,
+                    onpass="ONOS shows 1 SCC",
+                    onfail="ONOS shows "+str(num_clusters) +" SCCs")
+
+
+            #paths
+            consistent_paths_result = main.TRUE
+            for controller in range( len( paths ) ):
+                if not "Error" in paths[controller]:
+                    if paths[controller] == paths[0]:
+                        continue
+                    else:#paths not consistent
+                        main.log.report("paths from ONOS" + str(controller + 1) + " is inconsistent with ONOS1")
+                        consistent_paths_result = main.FALSE
+
+                else:
+                    main.log.report("Error in getting paths from ONOS" + str(controller + 1) )
+                    consistent_paths_result = main.FALSE
+                    main.log.warn("ONOS" + str(controller + 1) + " paths response: " + repr(paths[controller]) )
+            utilities.assert_equals(expect = main.TRUE,actual=consistent_paths_result,
+                    onpass="Paths count is consistent across all ONOS nodes",
+                    onfail="ONOS nodes have different counts of paths")
+
+
+            topo_result = devices_results and ports_results and links_results\
+                    and consistent_hosts_result and consistent_clusters_result and consistent_paths_result
+
+        topo_result = topo_result and int(count <= 2)
+        note = "note it takes about "+str( int(cli_time) )+" seconds for the test to make all the cli calls to fetch the topology from each ONOS instance"
+        main.log.report("Very crass estimate for topology discovery/convergence("+ str(note) + "): " +\
                 str(elapsed) + " seconds, " + str(count) +" tries" )
         utilities.assert_equals(expect=main.TRUE, actual=topo_result,
                 onpass="Topology Check Test successful",
@@ -1000,7 +1454,7 @@
         '''
         #NOTE: You should probably run a topology check after this
 
-        link_sleep = int(main.params['timers']['LinkDiscovery'])
+        link_sleep = float(main.params['timers']['LinkDiscovery'])
 
         description = "Turn off a link to ensure that Link Discovery is working properly"
         main.log.report(description)
@@ -1022,7 +1476,7 @@
         '''
         #NOTE: You should probably run a topology check after this
 
-        link_sleep = int(main.params['timers']['LinkDiscovery'])
+        link_sleep = float(main.params['timers']['LinkDiscovery'])
 
         description = "Restore a link to ensure that Link Discovery is working properly"
         main.log.report(description)
@@ -1045,7 +1499,7 @@
         #NOTE: You should probably run a topology check after this
         import time
 
-        switch_sleep = int(main.params['timers']['SwitchDiscovery'])
+        switch_sleep = float(main.params['timers']['SwitchDiscovery'])
 
         description = "Killing a switch to ensure it is discovered correctly"
         main.log.report(description)
@@ -1054,13 +1508,18 @@
         #TODO: Make this switch parameterizable
         main.step("Kill s28 ")
         main.log.report("Deleting s28")
-        #FIXME: use new dynamic topo functions
         main.Mininet1.del_switch("s28")
         main.log.info("Waiting " + str(switch_sleep) + " seconds for switch down to be discovered")
         time.sleep(switch_sleep)
+        device = main.ONOScli1.get_device(dpid="0028")
         #Peek at the deleted switch
-        main.log.warn(main.ONOScli1.get_device(dpid="0028"))
-        #TODO do some sort of check here
+        main.log.warn( str(device) )
+        result = main.FALSE
+        if device and device['available'] == False:
+            result = main.TRUE
+        utilities.assert_equals(expect=main.TRUE,actual=result,
+                onpass="Kill switch succesful",
+                onfail="Failed to kill switch?")
 
     def CASE12 (self, main) :
         '''
@@ -1068,7 +1527,8 @@
         '''
         #NOTE: You should probably run a topology check after this
         import time
-        #FIXME: use new dynamic topo functions
+
+        switch_sleep = float(main.params['timers']['SwitchDiscovery'])
         description = "Adding a switch to ensure it is discovered correctly"
         main.log.report(description)
         main.case(description)
@@ -1080,7 +1540,7 @@
         main.Mininet1.add_link('s28', 's3')
         main.Mininet1.add_link('s28', 's6')
         main.Mininet1.add_link('s28', 'h28')
-        main.Mininet1.assign_sw_controller(sw="28",count=7,
+        main.Mininet1.assign_sw_controller(sw="28",count=num_controllers,
                 ip1=ONOS1_ip,port1=ONOS1_port,
                 ip2=ONOS2_ip,port2=ONOS2_port,
                 ip3=ONOS3_ip,port3=ONOS3_port,
@@ -1090,9 +1550,15 @@
                 ip7=ONOS7_ip,port7=ONOS7_port)
         main.log.info("Waiting " + str(switch_sleep) + " seconds for switch up to be discovered")
         time.sleep(switch_sleep)
-        #Peek at the added switch
-        main.log.warn(main.ONOScli1.get_device(dpid="0028"))
-        #TODO do some sort of check here
+        device = main.ONOScli1.get_device(dpid="0028")
+        #Peek at the deleted switch
+        main.log.warn( str(device) )
+        result = main.FALSE
+        if device and device['available'] == True:
+            result = main.TRUE
+        utilities.assert_equals(expect=main.TRUE,actual=result,
+                onpass="add switch succesful",
+                onfail="Failed to add switch?")
 
     def CASE13 (self, main) :
         '''
@@ -1100,14 +1566,41 @@
         '''
         import os
         import time
+        #printing colors to terminal
+        colors = {}
+        colors['cyan']   = '\033[96m'
+        colors['purple'] = '\033[95m'
+        colors['blue']   = '\033[94m'
+        colors['green']  = '\033[92m'
+        colors['yellow'] = '\033[93m'
+        colors['red']    = '\033[91m'
+        colors['end']    = '\033[0m'
         description = "Test Cleanup"
         main.log.report(description)
         main.case(description)
         main.step("Killing tcpdumps")
         main.Mininet2.stop_tcpdump()
 
+        main.step("Checking ONOS Logs for errors")
+        print colors['purple'] + "Checking logs for errors on ONOS1:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS1_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS2:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS2_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS3:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS3_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS4:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS4_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS5:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS5_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS6:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS6_ip)
+        print colors['purple'] + "Checking logs for errors on ONOS7:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS7_ip)
+
         main.step("Copying MN pcap and ONOS log files to test station")
         testname = main.TEST
+        teststation_user = main.params['TESTONUSER']
+        teststation_IP = main.params['TESTONIP']
         #NOTE: MN Pcap file is being saved to ~/packet_captures
         #       scp this file as MN and TestON aren't necessarily the same vm
         #FIXME: scp
@@ -1119,19 +1612,26 @@
         #NOTE: must end in /
         dst_dir = "~/packet_captures/"
         for f in log_files:
-            main.ONOSbench.secureCopy( "sdn", ONOS1_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS1_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS1-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS2_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS2_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS2-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS3_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS3_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS3-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS4_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS4_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS4-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS5_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS5_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS5-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS6_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS6_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS6-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS7_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS7_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS7-"+f )
 
         #std*.log's
@@ -1141,24 +1641,29 @@
         #NOTE: must end in /
         dst_dir = "~/packet_captures/"
         for f in log_files:
-            main.ONOSbench.secureCopy( "sdn", ONOS1_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS1_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS1-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS2_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS2_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS2-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS3_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS3_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS3-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS4_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS4_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS4-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS5_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS5_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS5-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS6_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS6_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS6-"+f )
-            main.ONOSbench.secureCopy( "sdn", ONOS7_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS7_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS7-"+f )
 
 
-
-
         #sleep so scp can finish
         time.sleep(10)
         main.step("Packing and rotating pcap archives")
@@ -1169,3 +1674,139 @@
         utilities.assert_equals(expect=main.TRUE, actual=main.TRUE,
                 onpass="Test cleanup successful",
                 onfail="Test cleanup NOT successful")
+
+    def CASE14 ( self, main ) :
+        '''
+        start election app on all onos nodes
+        '''
+        leader_result = main.TRUE
+        #install app on onos 1
+        main.log.info("Install leadership election app")
+        main.ONOScli1.feature_install("onos-app-election")
+        #wait for election
+        #check for leader
+        leader = main.ONOScli1.election_test_leader()
+        #verify leader is ONOS1
+        if leader == ONOS1_ip:
+            #all is well
+            pass
+        elif leader == None:
+            #No leader elected
+            main.log.report("No leader was elected")
+            leader_result = main.FALSE
+        elif leader == main.FALSE:
+            #error in  response
+            #TODO: add check for "Command not found:" in the driver, this means the app isn't loaded
+            main.log.report("Something is wrong with election_test_leader function, check the error logs")
+            leader_result = main.FALSE
+        else:
+            #error in  response
+            main.log.report("Unexpected response from election_test_leader function:'"+str(leader)+"'")
+            leader_result = main.FALSE
+
+
+
+
+        #install on other nodes and check for leader.
+        #Should be onos1 and each app should show the same leader
+        for controller in range(2,num_controllers+1):
+            node = getattr( main, ( 'ONOScli' + str( controller ) ) )#loop through ONOScli handlers
+            node.feature_install("onos-app-election")
+            leaderN = node.election_test_leader()
+            #verify leader is ONOS1
+            if leaderN == ONOS1_ip:
+                #all is well
+                pass
+            elif leaderN == main.FALSE:
+                #error in  response
+                #TODO: add check for "Command not found:" in the driver, this means the app isn't loaded
+                main.log.report("Something is wrong with election_test_leader function, check the error logs")
+                leader_result = main.FALSE
+            elif leader != leaderN:
+                leader_result = main.FALSE
+                main.log.report("ONOS" + str(controller) + " sees "+str(leaderN) +
+                        " as the leader of the election app. Leader should be "+str(leader) )
+        if leader_result:
+            main.log.report("Leadership election tests passed(consistent view of leader across listeners and a leader was elected)")
+        utilities.assert_equals(expect=main.TRUE, actual=leader_result,
+                onpass="Leadership election passed",
+                onfail="Something went wrong with Leadership election")
+
+    def CASE15 ( self, main ) :
+        '''
+        Check that Leadership Election is still functional
+        '''
+        leader_result = main.TRUE
+        description = "Check that Leadership Election is still functional"
+        main.log.report(description)
+        main.case(description)
+        main.step("Find current leader and withdraw")
+        leader = main.ONOScli1.election_test_leader()
+        #TODO: do some sanity checking on leader before using it
+        withdraw_result = main.FALSE
+        if leader == ONOS1_ip:
+            old_leader = getattr( main, "ONOScli1" )
+        elif leader == ONOS2_ip:
+            old_leader = getattr( main, "ONOScli2" )
+        elif leader == ONOS3_ip:
+            old_leader = getattr( main, "ONOScli3" )
+        elif leader == ONOS4_ip:
+            old_leader = getattr( main, "ONOScli4" )
+        elif leader == ONOS5_ip:
+            old_leader = getattr( main, "ONOScli5" )
+        elif leader == ONOS6_ip:
+            old_leader = getattr( main, "ONOScli6" )
+        elif leader == ONOS7_ip:
+            old_leader = getattr( main, "ONOScli7" )
+        elif leader == None or leader == main.FALSE:
+            main.log.report("Leader for the election app should be an ONOS node,"\
+                    +"instead got '"+str(leader)+"'")
+            leader_result = main.FALSE
+        withdraw_result = old_leader.election_test_withdraw()
+
+
+        main.step("Make sure new leader is elected")
+        leader_list = []
+        for controller in range(1,num_controllers+1):
+            node = getattr( main, ( 'ONOScli' + str( controller ) ) )#loop through ONOScli handlers
+            leader_list.append( node.election_test_leader() )
+        for leaderN in leader_list:
+            if leaderN == leader:
+                main.log.report("ONOS"+str(controller)+" still sees " + str(leader) +\
+                        " as leader after they withdrew")
+                leader_result = main.FALSE
+            elif leaderN == main.FALSE:
+                #error in  response
+                #TODO: add check for "Command not found:" in the driver, this means the app isn't loaded
+                main.log.report("Something is wrong with election_test_leader function, check the error logs")
+                leader_result = main.FALSE
+        consistent_leader = main.FALSE
+        if len( set( leader_list ) ) == 1:
+            main.log.info("Each Election-app sees '"+str(leader_list[0])+"' as the leader")
+            consistent_leader = main.TRUE
+        else:
+            main.log.report("Inconsistent responses for leader of Election-app:")
+            for n in range(len(leader_list)):
+                main.log.report("ONOS" + str(n+1) + " response: " + str(leader_list[n]) )
+        if leader_result:
+            main.log.report("Leadership election tests passed(consistent view of leader across listeners and a new leader was elected when the old leader resigned)")
+        utilities.assert_equals(expect=main.TRUE, actual=leader_result,
+                onpass="Leadership election passed",
+                onfail="Something went wrong with Leadership election")
+
+
+        main.step("Run for election on old leader(just so everyone is in the hat)")
+        run_result = old_leader.election_test_run()
+        if consistent_leader == main.TRUE:
+            after_run = main.ONOScli1.election_test_leader()
+            #verify leader didn't just change
+            if after_run == leader_list[0]:
+                leader_result = main.TRUE
+            else:
+                leader_result = main.FALSE
+        #TODO: assert on  run and withdraw results?
+
+        utilities.assert_equals(expect=main.TRUE, actual=leader_result,
+                onpass="Leadership election passed",
+                onfail="Something went wrong with Leadership election after the old leader re-ran for election")
+
diff --git a/TestON/tests/SingleInstanceHATestRestart/SingleInstanceHATestRestart.params b/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.params
similarity index 83%
rename from TestON/tests/SingleInstanceHATestRestart/SingleInstanceHATestRestart.params
rename to TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.params
index e1e75f9..95a75d7 100644
--- a/TestON/tests/SingleInstanceHATestRestart/SingleInstanceHATestRestart.params
+++ b/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.params
@@ -1,9 +1,10 @@
 <PARAMS>
-    <testcases>1,2,8,3,4,5,[6],7,8,4,9,8,4,10,8,4,11,8,4,12,8,4,13</testcases>
+    <testcases>1,2,8,3,4,5,14,[6],8,3,7,4,15,9,8,4,10,8,4,11,8,4,12,8,4,13</testcases>
     <ENV>
     <cellName>HA</cellName>
     </ENV>
-    <Git>True</Git>
+    <Git>False</Git>
+    <num_controllers> 1 </num_controllers>
 
     <CTRL>
         <ip1>10.128.30.11</ip1>
@@ -28,7 +29,7 @@
         <port7>6633</port7>
     </CTRL>
     <TESTONUSER>admin</TESTONUSER>
-    <TESTONIP>10.128.30.10</TESTONIP>
+    <TESTONIP>10.128.30.9</TESTONIP>
     <PING>
         <source1>h8</source1>
         <source2>h9</source2>
@@ -52,8 +53,8 @@
         <target10>10.0.0.27</target10>
     </PING>
     <timers>
-        <LinkDiscovery>2</LinkDiscovery>
-        <SwitchDiscovery>2</SwitchDiscovery>
+        <LinkDiscovery>.2</LinkDiscovery>
+        <SwitchDiscovery>.2</SwitchDiscovery>
     </timers>
     <MNtcpdump>
         <intf>eth0</intf>
diff --git a/TestON/tests/SingleInstanceHATestRestart/SingleInstanceHATestRestart.py b/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.py
similarity index 64%
rename from TestON/tests/SingleInstanceHATestRestart/SingleInstanceHATestRestart.py
rename to TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.py
index e6f2fde..51ac0f6 100644
--- a/TestON/tests/SingleInstanceHATestRestart/SingleInstanceHATestRestart.py
+++ b/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.py
@@ -16,8 +16,10 @@
 CASE11: Switch down
 CASE12: Switch up
 CASE13: Clean up
+CASE14: start election app on all onos nodes
+CASE15: Check that Leadership Election is still functional
 '''
-class SingleInstanceHATestRestart:
+class HATestSingleInstanceRestart:
 
     def __init__(self) :
         self.default = ''
@@ -61,6 +63,7 @@
         global ONOS6_port
         global ONOS7_ip
         global ONOS7_port
+        global num_controllers
 
         ONOS1_ip = main.params['CTRL']['ip1']
         ONOS1_port = main.params['CTRL']['port1']
@@ -76,6 +79,7 @@
         ONOS6_port = main.params['CTRL']['port6']
         ONOS7_ip = main.params['CTRL']['ip7']
         ONOS7_port = main.params['CTRL']['port7']
+        num_controllers = int(main.params['num_controllers'])
 
 
         main.step("Applying cell variable to environment")
@@ -112,6 +116,8 @@
                         "clean install")
         main.ONOSbench.get_version(report=True)
 
+        cell_result = main.ONOSbench.set_cell("SingleHA")
+        verify_result = main.ONOSbench.verify_cell()
         main.step("Creating ONOS package")
         package_result = main.ONOSbench.onos_package()
 
@@ -121,17 +127,18 @@
 
 
         main.step("Checking if ONOS is up yet")
-        #TODO: Refactor
-        # check bundle:list?
-        #this should be enough for ONOS to start
-        time.sleep(60)
-        onos1_isup = main.ONOSbench.isup(ONOS1_ip)
+        #TODO check bundle:list?
+        for i in range(2):
+            onos1_isup = main.ONOSbench.isup(ONOS1_ip)
+            if onos1_isup:
+                break
         if not onos1_isup:
             main.log.report("ONOS1 didn't start!")
+
         # TODO: if it becomes an issue, we can retry this step  a few times
 
 
-        cli_result1 = main.ONOScli1.start_onos_cli(ONOS1_ip)
+        cli_result = main.ONOScli1.start_onos_cli(ONOS1_ip)
 
         main.step("Start Packet Capture MN")
         main.Mininet2.start_tcpdump(
@@ -142,7 +149,7 @@
 
         case1_result = (clean_install_result and package_result and
                 cell_result and verify_result and onos1_install_result and
-                onos1_isup and cli1_results)
+                onos1_isup and cli_result)
 
         utilities.assert_equals(expect=main.TRUE, actual=case1_result,
                 onpass="Test startup successful",
@@ -186,8 +193,6 @@
                 onpass="Switch mastership assigned correctly",
                 onfail="Switches not assigned correctly to controllers")
 
-        #TODO: If assign roles is working reliably then manually 
-        #   assign mastership to the controller we want
 
 
     def CASE3(self,main) :
@@ -195,6 +200,7 @@
         Assign intents
 
         """
+        #FIXME: we must reinstall intents until we have a persistant datastore!
         import time
         import json
         import re
@@ -204,6 +210,10 @@
         main.step("Discovering  Hosts( Via pingall for now)")
         #FIXME: Once we have a host discovery mechanism, use that instead
 
+        #install onos-app-fwd
+        main.log.info("Install reactive forwarding app")
+        main.ONOScli1.feature_install("onos-app-fwd")
+
         #REACTIVE FWD test
         ping_result = main.FALSE
         time1 = time.time()
@@ -214,22 +224,30 @@
         #uninstall onos-app-fwd
         main.log.info("Uninstall reactive forwarding app")
         main.ONOScli1.feature_uninstall("onos-app-fwd")
+        #timeout for fwd flows
+        time.sleep(10)
 
         main.step("Add  host intents")
         #TODO:  move the host numbers to params
         import json
         intents_json= json.loads(main.ONOScli1.hosts())
-        intent_add_result = main.FALSE
+        intent_add_result = True
         for i in range(8,18):
             main.log.info("Adding host intent between h"+str(i)+" and h"+str(i+10))
             host1 =  "00:00:00:00:00:" + str(hex(i)[2:]).zfill(2).upper()
             host2 =  "00:00:00:00:00:" + str(hex(i+10)[2:]).zfill(2).upper()
-            #NOTE: get host can return None
-            #TODO: handle this
             host1_id = main.ONOScli1.get_host(host1)['id']
             host2_id = main.ONOScli1.get_host(host2)['id']
-            tmp_result = main.ONOScli1.add_host_intent(host1_id, host2_id )
-            intent_add_result = intent_add_result and tmp_result
+            #NOTE: get host can return None
+            if host1_id and host2_id:
+                tmp_result = main.ONOScli1.add_host_intent(host1_id, host2_id )
+            else:
+                main.log.error("Error, get_host() failed")
+                tmp_result = main.FALSE
+            intent_add_result = bool(intent_add_result and tmp_result)
+        utilities.assert_equals(expect=True, actual=intent_add_result,
+                onpass="Switch mastership correctly assigned",
+                onfail="Error in (re)assigning switch mastership")
         #TODO Check if intents all exist in datastore
         #NOTE: Do we need to print this once the test is working?
         #main.log.info(json.dumps(json.loads(main.ONOScli1.intents(json_format=True)),
@@ -275,6 +293,15 @@
 
         main.step("Get the Mastership of each switch from each controller")
         global mastership_state
+        mastership_state = []
+
+        #Assert that each device has a master
+        roles_not_null = main.ONOScli1.roles_not_null()
+        utilities.assert_equals(expect = main.TRUE,actual=roles_not_null,
+                onpass="Each device has a master",
+                onfail="Some devices don't have a master assigned")
+
+
         ONOS1_mastership = main.ONOScli1.roles()
         #print json.dumps(json.loads(ONOS1_mastership), sort_keys=True, indent=4, separators=(',', ': '))
         #TODO: Make this a meaningful check
@@ -285,14 +312,11 @@
         else:
             mastership_state = ONOS1_mastership
             consistent_mastership = main.TRUE
-            main.log.report("Switch roles are consistent across all ONOS nodes")
-        utilities.assert_equals(expect = main.TRUE,actual=consistent_mastership,
-                onpass="Switch roles are consistent across all ONOS nodes",
-                onfail="ONOS nodes have different views of switch roles")
 
 
         main.step("Get the intents from each controller")
         global intent_state
+        intent_state = []
         ONOS1_intents = main.ONOScli1.intents( json_format=True )
         intent_check = main.FALSE
         if "Error" in ONOS1_intents or not ONOS1_intents:
@@ -300,14 +324,11 @@
             main.log.warn("ONOS1 intents response: " + repr(ONOS1_intents))
         else:
             intent_check = main.TRUE
-            main.log.report("Intents are consistent across all ONOS nodes")
-        utilities.assert_equals(expect = main.TRUE,actual=intent_check,
-                onpass="Intents are consistent across all ONOS nodes",
-                onfail="ONOS nodes have different views of intents")
 
 
         main.step("Get the flows from each controller")
         global flow_state
+        flow_state = []
         ONOS1_flows = main.ONOScli1.flows( json_format=True )
         flow_check = main.FALSE
         if "Error" in ONOS1_flows or not ONOS1_flows:
@@ -317,42 +338,16 @@
             #TODO: Do a better check, maybe compare flows on switches?
             flow_state = ONOS1_flows
             flow_check = main.TRUE
-            main.log.report("Flow count is consistent across all ONOS nodes")
-        utilities.assert_equals(expect = main.TRUE,actual=flow_check,
-                onpass="The flow count is consistent across all ONOS nodes",
-                onfail="ONOS nodes have different flow counts")
 
 
         main.step("Get the OF Table entries")
         global flows
         flows=[]
         for i in range(1,29):
-            flows.append(main.Mininet2.get_flowTable("s"+str(i),1.0))
+            flows.append(main.Mininet2.get_flowTable(1.3, "s"+str(i)))
 
         #TODO: Compare switch flow tables with ONOS flow tables
 
-        main.step("Start continuous pings")
-        main.Mininet2.pingLong(src=main.params['PING']['source1'],
-                            target=main.params['PING']['target1'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source2'],
-                            target=main.params['PING']['target2'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source3'],
-                            target=main.params['PING']['target3'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source4'],
-                            target=main.params['PING']['target4'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source5'],
-                            target=main.params['PING']['target5'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source6'],
-                            target=main.params['PING']['target6'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source7'],
-                            target=main.params['PING']['target7'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source8'],
-                            target=main.params['PING']['target8'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source9'],
-                            target=main.params['PING']['target9'],pingTime=500)
-        main.Mininet2.pingLong(src=main.params['PING']['source10'],
-                            target=main.params['PING']['target10'],pingTime=500)
-
         main.step("Create TestONTopology object")
         ctrls = []
         count = 1
@@ -381,7 +376,7 @@
         devices_results = main.TRUE
         ports_results = main.TRUE
         links_results = main.TRUE
-        for controller in range(1): #TODO parameterize the number of controllers
+        for controller in range(num_controllers):
             if devices[controller] or not "Error" in devices[controller]:
                 current_devices_result =  main.Mininet1.compare_switches(MNTopo, json.loads(devices[controller]))
             else:
@@ -417,7 +412,7 @@
 
         final_assert = main.TRUE
         final_assert = final_assert and topo_result and flow_check \
-                and intent_check and consistent_mastership
+                and intent_check and consistent_mastership and roles_not_null
         utilities.assert_equals(expect=main.TRUE, actual=final_assert,
                 onpass="State check successful",
                 onfail="State check NOT successful")
@@ -436,7 +431,7 @@
 
         main.step("Checking if ONOS is up yet")
         count = 0
-        while count < 10
+        while count < 10:
             onos1_isup = main.ONOSbench.isup(ONOS1_ip)
             if onos1_isup == main.TRUE:
                 elapsed = time.time() - start
@@ -446,11 +441,12 @@
 
         cli_result = main.ONOScli1.start_onos_cli(ONOS1_ip)
 
-        case_results = main.TRUE and onosi1_isup and cli_result
+        case_results = main.TRUE and onos1_isup and cli_result
         utilities.assert_equals(expect=main.TRUE, actual=case_results,
                 onpass="ONOS restart successful",
                 onfail="ONOS restart NOT successful")
-        main.log.info("ONOS took %s seconds to restart" % str(elapsed) )
+        main.log.info("ESTIMATE: ONOS took %s seconds to restart" % str(elapsed) )
+        time.sleep(5)
 
     def CASE7(self,main) :
         '''
@@ -460,6 +456,14 @@
         import json
         main.case("Running ONOS Constant State Tests")
 
+        #Assert that each device has a master
+        roles_not_null = main.ONOScli1.roles_not_null()
+        utilities.assert_equals(expect = main.TRUE,actual=roles_not_null,
+                onpass="Each device has a master",
+                onfail="Some devices don't have a master assigned")
+
+
+
         main.step("Check if switch roles are consistent across all nodes")
         ONOS1_mastership = main.ONOScli1.roles()
         #FIXME: Refactor this whole case for single instance
@@ -508,13 +512,14 @@
             main.log.report("Error in getting ONOS intents")
             main.log.warn("ONOS1 intents response: " + repr(ONOS1_intents))
         else:
-            intent_state = ONOS1_intents
             intent_check = main.TRUE
             main.log.report("Intents are consistent across all ONOS nodes")
         utilities.assert_equals(expect = main.TRUE,actual=intent_check,
                 onpass="Intents are consistent across all ONOS nodes",
                 onfail="ONOS nodes have different views of intents")
 
+        #NOTE: Hazelcast has no durability, so intents are lost
+        '''
         main.step("Compare current intents with intents before the failure")
         if intent_state == ONOS1_intents:
             same_intents = main.TRUE
@@ -526,6 +531,7 @@
                 onpass="Intents are consistent with before failure",
                 onfail="The Intents changed during failure")
         intent_check = intent_check and same_intents
+        '''
 
 
 
@@ -534,42 +540,48 @@
         flows2=[]
         for i in range(28):
             main.log.info("Checking flow table on s" + str(i+1))
-            tmp_flows = main.Mininet2.get_flowTable("s"+str(i+1),1.0)
+            tmp_flows = main.Mininet2.get_flowTable(1.3, "s"+str(i+1))
             flows2.append(tmp_flows)
-            Flow_Tables = Flow_Tables and main.Mininet2.flow_comp(flow1=flows[i],flow2=tmp_flows)
+            temp_result = main.Mininet2.flow_comp(flow1=flows[i],flow2=tmp_flows)
+            Flow_Tables = Flow_Tables and temp_result
             if Flow_Tables == main.FALSE:
                 main.log.info("Differences in flow table for switch: "+str(i+1))
-                break
         if Flow_Tables == main.TRUE:
             main.log.report("No changes were found in the flow tables")
         utilities.assert_equals(expect=main.TRUE,actual=Flow_Tables,
                 onpass="No changes were found in the flow tables",
                 onfail="Changes were found in the flow tables")
 
-        main.step("Check the continuous pings to ensure that no packets were dropped during component failure")
-        #FIXME: This check is always failing. Investigate cause
-        #NOTE:  this may be something to do with file permsissions
-        #       or slight change in format
-        main.Mininet2.pingKill(main.params['TESTONUSER'], main.params['TESTONIP'])
-        Loss_In_Pings = main.FALSE 
-        #NOTE: checkForLoss returns main.FALSE with 0% packet loss
-        for i in range(8,18):
-            main.log.info("Checking for a loss in pings along flow from s" + str(i))
-            Loss_In_Pings = Loss_In_Pings or main.Mininet2.checkForLoss("/tmp/ping.h"+str(i))
-        if Loss_In_Pings == main.TRUE:
-            main.log.info("Loss in ping detected")
-        elif Loss_In_Pings == main.ERROR:
-            main.log.info("There are multiple mininet process running")
-        elif Loss_In_Pings == main.FALSE:
-            main.log.info("No Loss in the pings")
-            main.log.report("No loss of dataplane connectivity")
-        utilities.assert_equals(expect=main.FALSE,actual=Loss_In_Pings,
-                onpass="No Loss of connectivity",
-                onfail="Loss of dataplane connectivity detected")
+
+        #Test of LeadershipElection
+
+        leader = ONOS1_ip
+        leader_result = main.TRUE
+        for controller in range(1,num_controllers+1):
+            node = getattr( main, ( 'ONOScli' + str( controller ) ) )#loop through ONOScli handlers
+            leaderN = node.election_test_leader()
+            #verify leader is ONOS1
+            #NOTE even though we restarted ONOS, it is the only one so onos 1 must be leader
+            if leaderN == leader:
+                #all is well
+                pass
+            elif leaderN == main.FALSE:
+                #error in  response
+                main.log.report("Something is wrong with election_test_leader function, check the error logs")
+                leader_result = main.FALSE
+            elif leader != leaderN:
+                leader_result = main.FALSE
+                main.log.report("ONOS" + str(controller) + " sees "+str(leaderN) +
+                        " as the leader of the election app. Leader should be "+str(leader) )
+        if leader_result:
+            main.log.report("Leadership election tests passed(consistent view of leader across listeners and a new leader was re-elected if applicable)")
+        utilities.assert_equals(expect=main.TRUE, actual=leader_result,
+                onpass="Leadership election passed",
+                onfail="Something went wrong with Leadership election")
 
 
-        #TODO:add topology to this or leave as a seperate case?
-        result = mastership_check and intent_check and Flow_Tables and (not Loss_In_Pings)
+        result = mastership_check and intent_check and Flow_Tables and roles_not_null\
+                and leader_result
         result = int(result)
         if result == main.TRUE:
             main.log.report("Constant State Tests Passed")
@@ -606,62 +618,62 @@
         ports_results = main.TRUE
         links_results = main.TRUE
         topo_result = main.FALSE
-        start_time = time.time()
         elapsed = 0
         count = 0
-        while topo_result == main.FALSE and elapsed < 120:
+        main.step("Collecting topology information from ONOS")
+        start_time = time.time()
+        while topo_result == main.FALSE and elapsed < 60:
             count = count + 1
-            try:
-                main.step("Collecting topology information from ONOS")
-                devices = []
-                devices.append( main.ONOScli1.devices() )
-                '''
-                hosts = []
-                hosts.append( main.ONOScli1.hosts() )
-                '''
-                ports = []
-                ports.append( main.ONOScli1.ports() )
-                links = []
-                links.append( main.ONOScli1.links() )
-                for controller in range(1): #TODO parameterize the number of controllers
-                    if devices[controller] or not "Error" in devices[controller]:
-                        current_devices_result =  main.Mininet1.compare_switches(MNTopo, json.loads(devices[controller]))
-                    else:
-                        current_devices_result = main.FALSE
-                    utilities.assert_equals(expect=main.TRUE, actual=current_devices_result,
-                            onpass="ONOS"+str(int(controller+1))+" Switches view is correct",
-                            onfail="ONOS"+str(int(controller+1))+" Switches view is incorrect")
+            if count > 1:
+                MNTopo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
+            cli_start = time.time()
+            devices = []
+            devices.append( main.ONOScli1.devices() )
+            '''
+            hosts = []
+            hosts.append( main.ONOScli1.hosts() )
+            '''
+            ports = []
+            ports.append( main.ONOScli1.ports() )
+            links = []
+            links.append( main.ONOScli1.links() )
+            elapsed = time.time() - start_time
+            print "CLI time: " + str(time.time() - cli_start)
 
-                    if ports[controller] or not "Error" in ports[controller]:
-                        current_ports_result =  main.Mininet1.compare_ports(MNTopo, json.loads(ports[controller]))
-                    else:
-                        current_ports_result = main.FALSE
-                    utilities.assert_equals(expect=main.TRUE, actual=current_ports_result,
-                            onpass="ONOS"+str(int(controller+1))+" ports view is correct",
-                            onfail="ONOS"+str(int(controller+1))+" ports view is incorrect")
+            for controller in range(num_controllers):
+                if devices[controller] or not "Error" in devices[controller]:
+                    current_devices_result =  main.Mininet1.compare_switches(MNTopo, json.loads(devices[controller]))
+                else:
+                    current_devices_result = main.FALSE
+                utilities.assert_equals(expect=main.TRUE, actual=current_devices_result,
+                        onpass="ONOS"+str(int(controller+1))+" Switches view is correct",
+                        onfail="ONOS"+str(int(controller+1))+" Switches view is incorrect")
 
-                    if links[controller] or not "Error" in links[controller]:
-                        current_links_result =  main.Mininet1.compare_links(MNTopo, json.loads(links[controller]))
-                    else:
-                        current_links_result = main.FALSE
-                    utilities.assert_equals(expect=main.TRUE, actual=current_links_result,
-                            onpass="ONOS"+str(int(controller+1))+" links view is correct",
-                            onfail="ONOS"+str(int(controller+1))+" links view is incorrect")
-            except:
-                main.log.error("something went wrong in topo comparison")
-                main.log.warn( repr( devices ) )
-                main.log.warn( repr( ports ) )
-                main.log.warn( repr( links ) )
+                if ports[controller] or not "Error" in ports[controller]:
+                    current_ports_result =  main.Mininet1.compare_ports(MNTopo, json.loads(ports[controller]))
+                else:
+                    current_ports_result = main.FALSE
+                utilities.assert_equals(expect=main.TRUE, actual=current_ports_result,
+                        onpass="ONOS"+str(int(controller+1))+" ports view is correct",
+                        onfail="ONOS"+str(int(controller+1))+" ports view is incorrect")
 
+                if links[controller] or not "Error" in links[controller]:
+                    current_links_result =  main.Mininet1.compare_links(MNTopo, json.loads(links[controller]))
+                else:
+                    current_links_result = main.FALSE
+                utilities.assert_equals(expect=main.TRUE, actual=current_links_result,
+                        onpass="ONOS"+str(int(controller+1))+" links view is correct",
+                        onfail="ONOS"+str(int(controller+1))+" links view is incorrect")
             devices_results = devices_results and current_devices_result
             ports_results = ports_results and current_ports_result
             links_results = links_results and current_links_result
-            elapsed = time.time() - start_time
-        time_threshold = elapsed < 1
-        topo_result = devices_results and ports_results and links_results and time_threshold
-        #TODO make sure this step is non-blocking. IE add a timeout
-        main.log.report("Very crass estimate for topology discovery/convergence: " +\
+            topo_result = devices_results and ports_results and links_results
+
+        topo_result = topo_result and int(count <= 2)
+        main.log.report("Very crass estimate for topology discovery/convergence(note it takes about 1 seconds to read the topology from each ONOS instance): " +\
                 str(elapsed) + " seconds, " + str(count) +" tries" )
+        if elapsed > 60:
+            main.log.report("Giving up on topology convergence")
         utilities.assert_equals(expect=main.TRUE, actual=topo_result,
                 onpass="Topology Check Test successful",
                 onfail="Topology Check Test NOT successful")
@@ -675,7 +687,7 @@
         '''
         #NOTE: You should probably run a topology check after this
 
-        link_sleep = int(main.params['timers']['LinkDiscovery'])
+        link_sleep = float(main.params['timers']['LinkDiscovery'])
 
         description = "Turn off a link to ensure that Link Discovery is working properly"
         main.log.report(description)
@@ -697,7 +709,7 @@
         '''
         #NOTE: You should probably run a topology check after this
 
-        link_sleep = int(main.params['timers']['LinkDiscovery'])
+        link_sleep = float(main.params['timers']['LinkDiscovery'])
 
         description = "Restore a link to ensure that Link Discovery is working properly"
         main.log.report(description)
@@ -720,7 +732,7 @@
         #NOTE: You should probably run a topology check after this
         import time
 
-        switch_sleep = int(main.params['timers']['SwitchDiscovery'])
+        switch_sleep = float(main.params['timers']['SwitchDiscovery'])
 
         description = "Killing a switch to ensure it is discovered correctly"
         main.log.report(description)
@@ -729,13 +741,18 @@
         #TODO: Make this switch parameterizable
         main.step("Kill s28 ")
         main.log.report("Deleting s28")
-        #FIXME: use new dynamic topo functions
         main.Mininet1.del_switch("s28")
         main.log.info("Waiting " + str(switch_sleep) + " seconds for switch down to be discovered")
         time.sleep(switch_sleep)
+        device = main.ONOScli1.get_device(dpid="0028")
         #Peek at the deleted switch
-        main.log.warn(main.ONOScli1.get_device(dpid="0028"))
-        #TODO do some sort of check here
+        main.log.warn( str(device) )
+        result = main.FALSE
+        if device and device['available'] == False:
+            result = main.TRUE
+        utilities.assert_equals(expect=main.TRUE,actual=result,
+                onpass="Kill switch succesful",
+                onfail="Failed to kill switch?")
 
     def CASE12 (self, main) :
         '''
@@ -743,7 +760,8 @@
         '''
         #NOTE: You should probably run a topology check after this
         import time
-        #FIXME: use new dynamic topo functions
+
+        switch_sleep = float(main.params['timers']['SwitchDiscovery'])
         description = "Adding a switch to ensure it is discovered correctly"
         main.log.report(description)
         main.case(description)
@@ -759,9 +777,15 @@
                 ip1=ONOS1_ip,port1=ONOS1_port)
         main.log.info("Waiting " + str(switch_sleep) + " seconds for switch up to be discovered")
         time.sleep(switch_sleep)
-        #Peek at the added switch
-        main.log.warn(main.ONOScli1.get_device(dpid="0028"))
-        #TODO do some sort of check here
+        device = main.ONOScli1.get_device(dpid="0028")
+        #Peek at the deleted switch
+        main.log.warn( str(device) )
+        result = main.FALSE
+        if device and device['available'] == True:
+            result = main.TRUE
+        utilities.assert_equals(expect=main.TRUE,actual=result,
+                onpass="add switch succesful",
+                onfail="Failed to add switch?")
 
     def CASE13 (self, main) :
         '''
@@ -769,14 +793,28 @@
         '''
         import os
         import time
+        #printing colors to terminal
+        colors = {}
+        colors['cyan']   = '\033[96m'
+        colors['purple'] = '\033[95m'
+        colors['blue']   = '\033[94m'
+        colors['green']  = '\033[92m'
+        colors['yellow'] = '\033[93m'
+        colors['red']    = '\033[91m'
+        colors['end']    = '\033[0m'
         description = "Test Cleanup"
         main.log.report(description)
         main.case(description)
         main.step("Killing tcpdumps")
         main.Mininet2.stop_tcpdump()
 
+        main.step("Checking ONOS Logs for errors")
+        print colors['purple'] + "Checking logs for errors on ONOS1:" + colors['end']
+        print main.ONOSbench.check_logs(ONOS1_ip)
         main.step("Copying MN pcap and ONOS log files to test station")
         testname = main.TEST
+        teststation_user = main.params['TESTONUSER']
+        teststation_IP = main.params['TESTONIP']
         #NOTE: MN Pcap file is being saved to ~/packet_captures
         #       scp this file as MN and TestON aren't necessarily the same vm
         #FIXME: scp
@@ -788,8 +826,11 @@
         #NOTE: must end in /
         dst_dir = "~/packet_captures/"
         for f in log_files:
-            main.ONOSbench.secureCopy( "sdn", ONOS1_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS1_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS1-"+f )
+            main.ONOSbench.handle.expect("\$")
+            print main.ONOSbench.handle.before
 
         #std*.log's
         #NOTE: must end in /
@@ -798,7 +839,8 @@
         #NOTE: must end in /
         dst_dir = "~/packet_captures/"
         for f in log_files:
-            main.ONOSbench.secureCopy( "sdn", ONOS1_ip,log_folder+f,"rocks",\
+            main.ONOSbench.handle.sendline( "scp sdn@"+ONOS1_ip+":"+log_folder+f+" "+
+                    teststation_user +"@"+teststation_IP+":"+\
                     dst_dir + str(testname) + "-ONOS1-"+f )
 
 
@@ -812,3 +854,117 @@
         utilities.assert_equals(expect=main.TRUE, actual=main.TRUE,
                 onpass="Test cleanup successful",
                 onfail="Test cleanup NOT successful")
+
+    def CASE14 ( self, main ) :
+        '''
+        start election app on all onos nodes
+        '''
+        leader_result = main.TRUE
+        #install app on onos 1
+        main.log.info("Install leadership election app")
+        main.ONOScli1.feature_install("onos-app-election")
+        #wait for election
+        #check for leader
+        leader = main.ONOScli1.election_test_leader()
+        #verify leader is ONOS1
+        if leader == ONOS1_ip:
+            #all is well
+            pass
+        elif leader == None:
+            #No leader elected
+            main.log.report("No leader was elected")
+            leader_result = main.FALSE
+        elif leader == main.FALSE:
+            #error in  response
+            #TODO: add check for "Command not found:" in the driver, this means the app isn't loaded
+            main.log.report("Something is wrong with election_test_leader function, check the error logs")
+            leader_result = main.FALSE
+        else:
+            #error in  response
+            main.log.report("Unexpected response from election_test_leader function:'"+str(leader)+"'")
+            leader_result = main.FALSE
+
+
+
+
+        #install on other nodes and check for leader.
+        #Should be onos1 and each app should show the same leader
+        for controller in range(2,num_controllers+1):
+            node = getattr( main, ( 'ONOScli' + str( controller ) ) )#loop through ONOScli handlers
+            node.feature_install("onos-app-election")
+            leaderN = node.election_test_leader()
+            #verify leader is ONOS1
+            if leaderN == ONOS1_ip:
+                #all is well
+                pass
+            elif leaderN == main.FALSE:
+                #error in  response
+                #TODO: add check for "Command not found:" in the driver, this means the app isn't loaded
+                main.log.report("Something is wrong with election_test_leader function, check the error logs")
+                leader_result = main.FALSE
+            elif leader != leaderN:
+                leader_result = main.FALSE
+                main.log.report("ONOS" + str(controller) + " sees "+str(leaderN) +
+                        " as the leader of the election app. Leader should be "+str(leader) )
+        if leader_result:
+            main.log.report("Leadership election tests passed(consistent view of leader across listeners and a leader was elected)")
+        utilities.assert_equals(expect=main.TRUE, actual=leader_result,
+                onpass="Leadership election passed",
+                onfail="Something went wrong with Leadership election")
+
+    def CASE15 ( self, main ) :
+        '''
+        Check that Leadership Election is still functional
+        '''
+        leader_result = main.TRUE
+        description = "Check that Leadership Election is still functional"
+        main.log.report(description)
+        main.case(description)
+        main.step("Find current leader and withdraw")
+        leader = main.ONOScli1.election_test_leader()
+        #TODO: do some sanity checking on leader before using it
+        withdraw_result = main.FALSE
+        if leader == ONOS1_ip:
+            old_leader = getattr( main, "ONOScli1" )
+        elif leader == None or leader == main.FALSE:
+            main.log.report("Leader for the election app should be an ONOS node,"\
+                    +"instead got '"+str(leader)+"'")
+            leader_result = main.FALSE
+        withdraw_result = old_leader.election_test_withdraw()
+
+
+        main.step("Make sure new leader is elected")
+        leader_list = []
+        leaderN =  main.ONOScli1.election_test_leader() 
+        if leaderN == leader:
+            main.log.report("ONOS"+str(controller)+" still sees " + str(leader) +\
+                    " as leader after they withdrew")
+            leader_result = main.FALSE
+        elif leaderN == main.FALSE:
+            #error in  response
+            #TODO: add check for "Command not found:" in the driver, this means the app isn't loaded
+            main.log.report("Something is wrong with election_test_leader function, check the error logs")
+            leader_result = main.FALSE
+        elif leaderN == None:
+            main.log.info("There is no leader after the app withdrew from election")
+        if leader_result:
+            main.log.report("Leadership election tests passed(There is no leader after the old leader resigned)")
+        utilities.assert_equals(expect=main.TRUE, actual=leader_result,
+                onpass="Leadership election passed",
+                onfail="Something went wrong with Leadership election")
+
+
+        main.step("Run for election on old leader(just so everyone is in the hat)")
+        run_result = old_leader.election_test_run()
+        leader = main.ONOScli1.election_test_leader()
+        #verify leader is ONOS1
+        if leader == ONOS1_ip:
+            leader_result = main.TRUE
+        else:
+            leader_result = main.FALSE
+        #TODO: assert on  run and withdraw results?
+
+        utilities.assert_equals(expect=main.TRUE, actual=leader_result,
+                onpass="Leadership election passed",
+                onfail="ONOS1's election app was not leader after it re-ran for election")
+
diff --git a/TestON/tests/SingleInstanceHATestRestart/SingleInstanceHATestRestart.topo b/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.topo
similarity index 100%
rename from TestON/tests/SingleInstanceHATestRestart/SingleInstanceHATestRestart.topo
rename to TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.topo
diff --git a/TestON/tests/SingleInstanceHATestRestart/__init__.py b/TestON/tests/HATestSingleInstanceRestart/__init__.py
similarity index 100%
rename from TestON/tests/SingleInstanceHATestRestart/__init__.py
rename to TestON/tests/HATestSingleInstanceRestart/__init__.py
diff --git a/TestON/tests/HPSwitchTest/HPSwitchTest.params b/TestON/tests/HPSwitchTest/HPSwitchTest.params
deleted file mode 100644
index 92a5b20..0000000
--- a/TestON/tests/HPSwitchTest/HPSwitchTest.params
+++ /dev/null
@@ -1,4 +0,0 @@
-<PARAMS>
-    <testcases> [1]</testcases>
-    <mail> anil4haart@gmail.com,paxweb@paxterrasolutions.com</mail>
-</PARAMS>
\ No newline at end of file
diff --git a/TestON/tests/HPSwitchTest/HPSwitchTest.py b/TestON/tests/HPSwitchTest/HPSwitchTest.py
deleted file mode 100644
index 9e2e4e7..0000000
--- a/TestON/tests/HPSwitchTest/HPSwitchTest.py
+++ /dev/null
@@ -1,23 +0,0 @@
-'''
-	
- *   TestON is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 2 of the License, or
- *   (at your option) any later version.
-
- *   TestON is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
-
-
-'''
-class HPSwitchTest :
-
-    def __init__(self) :
-        self.default = ''
-
-    def CASE1(self,main) :
-
-        main.case("HPSwitchTest Sample Test")
-        main.step("HPSwitchTest Sample Test")
diff --git a/TestON/tests/HPSwitchTest/HPSwitchTest.topo b/TestON/tests/HPSwitchTest/HPSwitchTest.topo
deleted file mode 100644
index c6ad886..0000000
--- a/TestON/tests/HPSwitchTest/HPSwitchTest.topo
+++ /dev/null
@@ -1,14 +0,0 @@
-<TOPOLOGY>
-
-    <COMPONENT>
-        <HPSwitch>
-            <host>24.6.49.222</host>
-            <user> Paxterra </user>
-            <port> 6500 </port>
-            <password></password>
-            <type>RemoteSysDriver</type>
-            <COMPONENTS>
-            </COMPONENTS>   
-        </HPSwitch>        
-    </COMPONENT>
-</TOPOLOGY>
diff --git a/TestON/tests/HPSwitchTest/__init__.py b/TestON/tests/HPSwitchTest/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/TestON/tests/HPSwitchTest/__init__.py
+++ /dev/null
diff --git a/TestON/tests/IntentPerfNext/IntentPerfNext.params b/TestON/tests/IntentPerfNext/IntentPerfNext.params
index cdf0766..edba27b 100644
--- a/TestON/tests/IntentPerfNext/IntentPerfNext.params
+++ b/TestON/tests/IntentPerfNext/IntentPerfNext.params
@@ -1,5 +1,5 @@
 <PARAMS>
-    <testcases>1,5,2,3</testcases>
+    <testcases>1,5,7,2,3</testcases>
 
     <ENV>
         <cellName>intent_perf_test</cellName>
diff --git a/TestON/tests/IntentPerfNext/IntentPerfNext.py b/TestON/tests/IntentPerfNext/IntentPerfNext.py
index c212e9e..5c8bb2f 100644
--- a/TestON/tests/IntentPerfNext/IntentPerfNext.py
+++ b/TestON/tests/IntentPerfNext/IntentPerfNext.py
@@ -238,9 +238,9 @@
         intent_add_lat_std = \
             round(numpy.std(intent_add_lat_list),1)
         #END ITERATION FOR LOOP
-        main.log.report("Single intent add latency - \n"+
-                "Avg: "+str(intent_add_lat_avg)+" ms\n"+
-                "Std Deviation: "+str(intent_add_lat_std)+" ms")
+        main.log.report("Single intent add latency - ")
+        main.log.report("Avg: "+str(intent_add_lat_avg)+" ms")
+        main.log.report("Std Deviation: "+str(intent_add_lat_std)+" ms")
 
     def CASE3(self, main):
         '''
@@ -281,8 +281,6 @@
 
         intent_reroute_lat_list = []
 
-        print device_id_list
-
         for i in range(0, int(num_iter)):
             #add_point_intent(ingr_device, ingr_port, 
             #                 egr_device, egr_port)
@@ -308,7 +306,7 @@
             #NOTE: this interface is specific to
             #      topo-intentFlower.py topology
             #      reroute case.
-            main.log.info("Disabling interface s2-eth3 <--> s4")
+            main.log.info("Disabling interface s2-eth3")
             main.Mininet1.handle.sendline(
                     "sh ifconfig s2-eth3 down")
             t0_system = time.time()*1000
@@ -355,16 +353,7 @@
                 main.log.info("Intent reroute latency exceeded "+
                         "threshold. Skipping iteration "+str(i))
 
-            #TODO: Possibly put this in the driver function
             main.log.info("Removing intents for next iteration")
-            
-            #NOTE: TODO: Currently, the remove intent will
-            #            not trigger the intent request 
-            #            timestamp. Thus we cannot use the same
-            #            intent to get the latency over iterations.
-            #            we can 1) install different intents every
-            #            time, or 2) look into state machine and 
-            #            determine what timestsamp to get
             main.ONOS1cli.remove_intent(intent_id)
             
             main.log.info("Bringing Mininet interface up for next "+
@@ -377,11 +366,150 @@
         intent_reroute_lat_std = \
             round(numpy.std(intent_reroute_lat_list),1)
         #END ITERATION FOR LOOP
-        main.log.report("Single intent reroute latency - \n"+
-                "Avg: "+str(intent_reroute_lat_avg)+" ms\n"+
-                "Std Deviation: "+str(intent_reroute_lat_std)+" ms")
+        main.log.report("Single intent reroute latency - ")
+        main.log.report("Avg: "+str(intent_reroute_lat_avg)+" ms")
+        main.log.report("Std Deviation: "+str(intent_reroute_lat_std)+" ms")
+        
+    def CASE7(self, main):
+        '''
+        Batch intent reroute latency
+        '''
+        import time
+        import json
+        import requests
+        import os
+        import numpy
+
+        ONOS_ip_list = []
+        for i in range(1, 8):
+            ONOS_ip_list.append(main.params['CTRL']['ip'+str(i)])
+
+        ONOS_user = main.params['CTRL']['user']
+        default_sw_port = main.params['CTRL']['port1']
+    
+        batch_intent_size = main.params['TEST']['batchIntentSize']
+        batch_thresh_min = int(main.params['TEST']['batchThresholdMin'])
+        batch_thresh_max = int(main.params['TEST']['batchThresholdMax'])
+        install_time = main.params['JSON']['installedTime']
+
+        #number of iterations of case
+        num_iter = main.params['TEST']['numIter']
+        num_ignore = int(main.params['TEST']['numIgnore'])
+        num_switch = int(main.params['TEST']['numSwitch'])
+        n_thread = main.params['TEST']['numMult']
+
+        main.log.report("Batch intent installation test of "+
+               batch_intent_size +" intents")
+
+        batch_result_list = []
+
+        #Assign 'linear' switch format for basic intent testing
+        main.Mininet1.assign_sw_controller(
+                sw="1", ip1=ONOS1_ip,port1=default_sw_port)
+        main.Mininet1.assign_sw_controller(
+                sw="2", ip1=ONOS2_ip,port1=default_sw_port)
+        main.Mininet1.assign_sw_controller(
+                sw="3", ip1=ONOS2_ip,port1=default_sw_port)
+        main.Mininet1.assign_sw_controller(
+                sw="4", ip1=ONOS2_ip,port1=default_sw_port)
+        main.Mininet1.assign_sw_controller(
+                sw="5", ip1=ONOS3_ip,port1=default_sw_port)
+
+        time.sleep(10)
+
+        main.log.info("Getting list of available devices")
+        device_id_list = []
+        json_str = main.ONOS1cli.devices()
+        json_obj = json.loads(json_str)
+        for device in json_obj:
+            device_id_list.append(device['id'])
+
+        batch_install_lat = []
+        batch_withdraw_lat = []
+        sleep_time = 10
+        
+        base_dir = "/tmp/"
+        max_install_lat = []
+
+        for i in range(0, int(num_iter)):
+            main.log.info("Pushing "+
+                    str(int(batch_intent_size)*int(n_thread))+
+                    " intents. Iteration "+str(i))
             
+            main.ONOS1cli.push_test_intents(
+                "of:0000000000000001/1",
+                "of:0000000000000005/1",
+                1000, num_mult="1", app_id="1")
+               
+            #TODO: Check for installation success then proceed
+            time.sleep(30)
+            
+            #NOTE: this interface is specific to
+            #      topo-intentFlower.py topology
+            #      reroute case.
+            main.log.info("Disabling interface s2-eth3")
+            main.Mininet1.handle.sendline(
+                    "sh ifconfig s2-eth3 down")
+            t0_system = time.time()*1000
+
+            #TODO: Wait sufficient time for intents to install
+            time.sleep(10)
+
+            #TODO: get intent installation time
+            
+            #Obtain metrics from ONOS 1, 2, 3
+            intents_json_str_1 = main.ONOS1cli.intents_events_metrics()
+            intents_json_str_2 = main.ONOS2cli.intents_events_metrics()
+            intents_json_str_3 = main.ONOS3cli.intents_events_metrics()
+
+            intents_json_obj_1 = json.loads(intents_json_str_1)
+            intents_json_obj_2 = json.loads(intents_json_str_2)
+            intents_json_obj_3 = json.loads(intents_json_str_3)
+
+            #Parse values from the json object
+            intent_install_1 = \
+                    intents_json_obj_1[install_time]['value']
+            intent_install_2 = \
+                    intents_json_obj_2[install_time]['value']
+            intent_install_3 = \
+                    intents_json_obj_3[install_time]['value']
+
+            intent_reroute_lat_1 = \
+                    int(intent_install_1) - int(t0_system)
+            intent_reroute_lat_2 = \
+                    int(intent_install_2) - int(t0_system)
+            intent_reroute_lat_3 = \
+                    int(intent_install_3) - int(t0_system)
+            
+            intent_reroute_lat_avg = \
+                    (intent_reroute_lat_1 + 
+                     intent_reroute_lat_2 +
+                     intent_reroute_lat_3 ) / 3
+    
+            main.log.info("Intent reroute latency avg for iteration "+
+                    str(i)+": "+str(intent_reroute_lat_avg))
+            #TODO: Remove intents for next iteration
+            
+            time.sleep(5)
+
+            intents_str = main.ONOS1cli.intents()
+            intents_json = json.loads(intents_str)
+            for intents in intents_json:
+                intent_id = intents['id']
+                if intent_id:
+                    main.ONOS1cli.remove_intent(intent_id)
+
+            main.Mininet1.handle.sendline(
+                    "sh ifconfig s2-eth3 up")
+            
+            main.log.info("Intents removed and port back up")
+
+
     def CASE4(self, main):
+        '''
+        Batch intent install
+        '''
+        
         import time
         import json
         import requests
@@ -596,7 +724,7 @@
 
         global cluster_count
         cluster_count += 2
-        main.log.info("Increasing cluster size to "+
+        main.log.report("Increasing cluster size to "+
                 str(cluster_count))
 
         install_result = main.FALSE
@@ -701,7 +829,7 @@
             main.ONOSbench.push_test_intents_shell(
                 arg1,
                 arg2, 
-                150, "/tmp/temp.txt", "10.128.174.1",
+                100, "/tmp/temp.txt", "10.128.174.1",
                 num_mult="10", app_id=appid,report=False)
             #main.ONOSbench.push_test_intents_shell(
             #    "of:0000000000001002/1",
@@ -714,5 +842,5 @@
             #    133, "/tmp/temp3.txt", "10.128.174.3",
             #    num_mult="6", app_id="3",report=False)
    
-            time.sleep(0.1)
+            time.sleep(0.2)
 
diff --git a/TestON/tests/JonTest/JonTest.params b/TestON/tests/JonTest/JonTest.params
deleted file mode 100755
index 4bb85e6..0000000
--- a/TestON/tests/JonTest/JonTest.params
+++ /dev/null
@@ -1,18 +0,0 @@
-<PARAMS>
-    
-    <testcases>1,4,3,7,8,9,7,8</testcases>
-    
-    <Git>True</Git>
-    #Environment variables
-    <ENV>
-        <cellName>multi</cellName>
-    </ENV>
-
-    <CTRL>
-        <ip1>10.128.30.11</ip1>
-        <port1>6633</port1>
-        <ip2>10.128.30.12</ip2>
-        <port2>6633</port2>
-    </CTRL>
-
-</PARAMS>
diff --git a/TestON/tests/JonTest/JonTest.py b/TestON/tests/JonTest/JonTest.py
deleted file mode 100755
index 8e53fd2..0000000
--- a/TestON/tests/JonTest/JonTest.py
+++ /dev/null
@@ -1,431 +0,0 @@
-
-#Testing the basic functionality of ONOS Next
-#For sanity and driver functionality excercises only.
-
-import time
-import sys
-import os
-import re
-
-class JonTest:
-    def __init__(self):
-        self.default = ''
-
-    def CASE1(self, main):
-        '''
-        Startup sequence:
-        git pull
-        mvn clean install
-        onos-package
-        cell <name>
-        onos-verify-cell
-        onos-install -f
-        onos-wait-for-start
-        '''
-        import time
-        
-        PULL_CODE = False
-        if main.params['Git'] == 'True':
-            PULL_CODE = True
-        cell_name = main.params['ENV']['cellName']
-        ONOS1_ip = main.params['CTRL']['ip1']
-        ONOS1_port = main.params['CTRL']['port1']
-        ONOS2_ip = main.params['CTRL']['ip2']
-        ONOS2_port = main.params['CTRL']['port2']
-        
-        main.case("Setting up test environment")
-        
-        main.step("Applying cell variable to environment")
-        cell_result = main.ONOSbench.set_cell(cell_name)
-        #cell_result = main.ONOSbench.set_cell("temp_cell_2")
-        verify_result = main.ONOSbench.verify_cell()
-
-        if PULL_CODE:
-            main.step("Git checkout and pull master")
-            #main.log.report("Skipping git pull")
-            main.ONOSbench.git_checkout("master")
-            git_pull_result = main.ONOSbench.git_pull()
-            main.log.report(main.ONOSbench.get_version())
-
-            main.step("Using mvn clean & install")
-            clean_install_result = main.FALSE
-            if git_pull_result == main.TRUE:
-                clean_install_result = main.ONOSbench.clean_install()
-            else:
-                main.log.report("did not pull new code so skipping mvn clean install")
-
-        main.step("Creating ONOS package")
-        package_result = main.ONOSbench.onos_package()
-
-        main.step("Installing ONOS package")
-        onos1_install_result = main.ONOSbench.onos_install(options="-f", node=ONOS1_ip)
-        onos2_install_result = main.ONOSbench.onos_install(options="-f", node=ONOS2_ip)
-        onos1_isup = main.ONOSbench.isup(ONOS1_ip)
-        onos2_isup = main.ONOSbench.isup(ONOS2_ip)
-   
-        main.step("Starting ONOS service")
-        start_result = main.TRUE
-        #start_result = main.ONOSbench.onos_start(ONOS1_ip)
-
-        main.ONOScli1.start_onos_cli(ONOS1_ip)
-        main.ONOScli2.start_onos_cli(ONOS2_ip)
-
-        case1_result = (clean_install_result and package_result and\
-                cell_result and verify_result and onos1_install_result and\
-                onos2_install_result and onos1_isup and onos2_isup )
-        utilities.assert_equals(expect=main.TRUE, actual=case1_result,
-                onpass="Test startup successful",
-                onfail="Test startup NOT successful")
-
-
-    def CASE11(self, main):
-        '''
-        Cleanup sequence:
-        onos-service <node_ip> stop
-        onos-uninstall
-
-        TODO: Define rest of cleanup
-        
-        '''
-
-        ONOS1_ip = main.params['CTRL']['ip1']
-
-        main.case("Cleaning up test environment")
-
-        main.step("Testing ONOS kill function")
-        kill_result = main.ONOSbench.onos_kill(ONOS1_ip)
-
-        main.step("Stopping ONOS service")
-        stop_result = main.ONOSbench.onos_stop(ONOS1_ip)
-
-        main.step("Uninstalling ONOS service") 
-        uninstall_result = main.ONOSbench.onos_uninstall()
-
-    def CASE3(self, main):
-        '''
-        Test 'onos' command and its functionality in driver
-        '''
-        
-        ONOS1_ip = main.params['CTRL']['ip1']
-
-        main.case("Testing 'onos' command")
-
-        main.step("Sending command 'onos -w <onos-ip> system:name'")
-        cmdstr1 = "system:name"
-        cmd_result1 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr1) 
-        main.log.info("onos command returned: "+cmd_result1)
-
-        main.step("Sending command 'onos -w <onos-ip> onos:topology'")
-        cmdstr2 = "onos:topology"
-        cmd_result2 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr2)
-        main.log.info("onos command returned: "+cmd_result2)
-        
-        main.step("Testing check_status")
-        check_status_results = main.FALSE
-        topology_result = main.ONOScli1.topology()
-        check_status_results =  main.ONOSbench.check_status(topology_result, 4, 6)
-        main.log.info("Results of check_status " + str(check_status_results))
-
-        main.step("Sending command 'onos -w <onos-ip> bundle:list'")
-        cmdstr3 = "bundle:list"
-        cmd_result3 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr3)
-        main.log.info("onos command returned: "+cmd_result3)
-        case3_result = (cmd_result1 and cmd_result2 and\
-                check_status_results and cmd_result3 )
-        utilities.assert_equals(expect=main.TRUE, actual=case3_result,
-                onpass="Test case 3 successful",
-                onfail="Test case 3 NOT successful")
-
-    def CASE4(self, main):
-        import re
-        import time
-        main.case("Pingall Test(No intents are added)")
-        main.step("Assigning switches to controllers")
-        for i in range(1,5): #1 to (num of switches +1)
-            main.Mininet1.assign_sw_controller(sw=str(i),count=2, 
-                    ip1=ONOS1_ip, port1=ONOS1_port,
-                    ip2=ONOS2_ip, port2=ONOS2_port)
-
-        switch_mastership = main.TRUE
-        for i in range (1,5):
-            response = main.Mininet1.get_sw_controller("s"+str(i))
-            print("Response is " + str(response))
-            if re.search("tcp:"+ONOS1_ip,response):
-                switch_mastership = switch_mastership and main.TRUE
-            else:
-                switch_mastership = main.FALSE
-
-
-        #REACTIVE FWD test
-        main.step("Pingall")
-        ping_result = main.FALSE
-        time1 = time.time()
-        ping_result = main.Mininet1.pingall()
-        time2 = time.time()
-        print "Time for pingall: %2f seconds" % (time2 - time1)
-      
-        case4_result = switch_mastership and ping_result
-        utilities.assert_equals(expect=main.TRUE, actual=case4_result,
-                onpass="Pingall Test successful",
-                onfail="Pingall Test NOT successful")
-
-    def CASE5(self, main):
-        '''
-        Test the ONOS-cli functionality
-        
-        Below are demonstrations of what the 
-        ONOS cli driver functions can be used for.
-        '''
-        import time
-        import json
-
-        cell_name = main.params['ENV']['cellName']
-        ONOS1_ip = main.params['CTRL']['ip1']
-        
-        main.case("Testing the ONOS-cli")
-        
-        main.step("Set cell for ONOS-cli environment")
-        main.ONOScli.set_cell(cell_name)
-
-        main.step("Start ONOS-cli")
-        main.ONOScli.start_onos_cli(ONOS1_ip)
-
-        main.step("issue command: onos:topology")
-        topology_obj = main.ONOScli.topology()
-
-        main.step("issue various feature:install <str> commands")
-        #main.ONOScli.feature_install("onos-app-fwd")
-        #main.ONOScli.feature_install("onos-rest")
-
-        main.step("Add a bad node")
-        node_result = main.ONOScli.add_node("111", "10.128.20.")
-        if node_result == main.TRUE:
-            main.log.info("Node successfully added")
-
-        main.step("Add a correct node")
-        node_result = main.ONOScli.add_node("111", "10.128.20.12")
-
-        main.step("Assign switches and list devices")
-        for i in range(1,8):
-            main.Mininet1.handle.sendline("sh ovs-vsctl set-controller s"+str(i)+
-                    " tcp:10.128.20.11")
-            main.Mininet1.handle.expect("mininet>")
-        #Need to sleep to allow switch add processing
-        time.sleep(5)
-        list_result = main.ONOScli.devices()
-        main.log.info(list_result)
-
-        main.step("Get all devices id")
-        devices_id_list = main.ONOScli.get_all_devices_id()
-        main.log.info(devices_id_list)
-
-        main.step("Get path and cost between device 1 and 7")
-        (path, cost) = main.ONOScli.paths(devices_id_list[0], devices_id_list[6])
-        main.log.info("Path: "+str(path))
-        main.log.info("Cost: "+str(cost))
-
-        main.step("Get nodes currently visible")
-        nodes_str = main.ONOScli.nodes()
-        main.log.info(nodes_str)
-
-        main.step("Get all nodes id's")
-        node_id_list = main.ONOScli.get_all_nodes_id()
-        main.log.info(node_id_list)
-
-        main.step("Set device "+str(devices_id_list[0])+" to role: standby")
-        device_role_result = main.ONOScli.device_role(
-                devices_id_list[0], node_id_list[0], "standby")
-        if device_role_result == main.TRUE:
-            main.log.report("Device role successfully set")
-
-        main.step("Revert device role to master")
-        device_role = main.ONOScli.device_role(
-                devices_id_list[0], node_id_list[0], "master")
-
-        main.step("Check devices / role again")
-        dev_result = main.ONOScli.devices()
-        main.log.info(dev_result)
-       
-        #Sample steps to push intents ***********
-        # * Obtain host id in ONOS format 
-        # * Push intents
-        main.step("Get list of hosts from Mininet")
-        host_list = main.Mininet2.get_hosts()
-        main.log.info(host_list)
-
-        main.step("Get host list in ONOS format")
-        host_onos_list = main.ONOScli.get_hosts_id(host_list)
-        main.log.info(host_onos_list)
-
-        main.step("Ensure that reactive forwarding is installed")
-        feature_result = main.ONOScli.feature_install("onos-app-fwd")
-
-        time.sleep(5)
-
-        main.Mininet2.handle.sendline("\r")
-        main.Mininet2.handle.sendline("h4 ping h5 -c 1")
-
-        time.sleep(5)
-
-        main.step("Get hosts")
-        main.ONOScli.handle.sendline("hosts")
-        main.ONOScli.handle.expect("onos>")
-        hosts = main.ONOScli.handle.before
-        main.log.info(hosts)
-
-        main.step("Install host-to-host-intents between h4 and h5")
-        intent_install = main.ONOScli.add_host_intent(
-                host_onos_list[3], host_onos_list[4])
-        main.log.info(intent_install)
-
-        main.step("Uninstall reactive forwarding to test host-to-host intent")
-        main.ONOScli.feature_uninstall("onos-app-fwd")
-
-        main.step("Get intents installed on ONOS")
-        get_intent_result = main.ONOScli.intents()
-        main.log.info(get_intent_result)
-        #****************************************
-
-
-    def CASE7(self, main):
-        '''
-        Test compare topo functions
-        '''
-        import sys
-        sys.path.append("/home/admin/sts") # Trying to remove some dependancies, #FIXME add this path to params
-        from sts.topology.teston_topology import TestONTopology # assumes that sts is already in you PYTHONPATH
-        import json
-
-        main.step("Create TestONTopology object")
-        ctrls = []
-        count = 1
-        while True:
-            temp = ()
-            if ('ip' + str(count)) in main.params['CTRL']:
-                temp = temp + (getattr(main,('ONOS' + str(count))),)
-                temp = temp + ("ONOS"+str(count),)
-                temp = temp + (main.params['CTRL']['ip'+str(count)],)
-                temp = temp + (eval(main.params['CTRL']['port'+str(count)]),)
-                ctrls.append(temp)
-                count = count + 1
-            else:
-                break
-        MNTopo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
-
-        ONOS1_ip = main.params['CTRL']['ip1']
-        ONOS2_ip = main.params['CTRL']['ip2']
-
-    
-        main.step("Collecting topology information from ONOS")
-        devices1 = main.ONOScli1.devices()
-        devices2 = main.ONOScli2.devices()
-        switch1 = main.ONOScli1.get_device("0000000000000001")
-        hosts1 = main.ONOScli1.hosts()
-        hosts2 = main.ONOScli2.hosts()
-        host1 = main.ONOScli1.get_host("00:00:00:00:00:01")
-        #print json.dumps(json.loads(hosts1), sort_keys=True,indent=4,separators=(',', ': '))
-        #print json.dumps(json.loads(hosts2), sort_keys=True,indent=4,separators=(',', ': '))
-        #print json.dumps(host1, sort_keys=True,indent=4,separators=(',', ': '))
-        ports1 = main.ONOScli1.ports()
-        ports2 = main.ONOScli2.ports()
-        links1 = main.ONOScli1.links()
-        links2 = main.ONOScli2.links()
-
-
-        main.step("Comparing ONOS topology to MN")
-        #results =  main.Mininet1.compare_topo(MNTopo, json.loads(devices))
-        switches_results1 =  main.Mininet1.compare_switches(MNTopo, json.loads(devices1))
-        utilities.assert_equals(expect=main.TRUE, actual=switches_results1,
-                onpass="ONOS1 Switches view is correct",
-                onfail="ONOS1 Switches view is incorrect")
-
-        switches_results2 =  main.Mininet1.compare_switches(MNTopo, json.loads(devices2))
-        utilities.assert_equals(expect=main.TRUE, actual=switches_results2,
-                onpass="ONOS2 Switches view is correct",
-                onfail="ONOS2 Switches view is incorrect")
-
-
-        ports_results1 =  main.Mininet1.compare_ports(MNTopo, json.loads(ports1))
-        utilities.assert_equals(expect=main.TRUE, actual=ports_results1,
-                onpass="ONOS1 Ports view is correct",
-                onfail="ONOS1 Ports view is incorrect")
-
-        ports_results2 =  main.Mininet1.compare_ports(MNTopo, json.loads(ports2))
-        utilities.assert_equals(expect=main.TRUE, actual=ports_results2,
-                onpass="ONOS2 Ports view is correct",
-                onfail="ONOS2 Ports view is incorrect")
-
-        links_results1 =  main.Mininet1.compare_links(MNTopo, json.loads(links1))
-        utilities.assert_equals(expect=main.TRUE, actual=links_results1,
-                onpass="ONOS1 Links view is correct",
-                onfail="ONOS1 Links view is incorrect")
-
-        links_results2 =  main.Mininet1.compare_links(MNTopo, json.loads(links2))
-        utilities.assert_equals(expect=main.TRUE, actual=links_results2,
-                onpass="ONOS2 Links view is correct",
-                onfail="ONOS2 Links view is incorrect")
-
-        topo_result = switches_results1 and switches_results2 \
-                and ports_results1 and ports_results2\
-                and links_results1 and links_results2
-        utilities.assert_equals(expect=main.TRUE, actual=topo_result,
-                onpass="Topology Check Test successful",
-                onfail="Topology Check Test NOT successful")
-
-    def CASE8(self, main):
-        '''
-        try doing some role assignments
-        '''
-        import time
-        print main.ONOScli1.devices()
-        print main.ONOScli1.device_role("of:0000000000000001", "    ", "none")
-        time.sleep(1)
-        roles = main.ONOScli1.roles()
-        roles2 = main.ONOScli2.roles()
-        print roles
-        print roles2
-        print main.ONOScli1.get_role("00001")
-
-        print main.ONOScli1.devices()
-        print main.ONOScli1.device_role("of:0000000000000001", "10.128.30.11", "master")
-        time.sleep(1)
-        roles = main.ONOScli1.roles()
-        roles2 = main.ONOScli2.roles()
-        print roles
-        print roles2
-        print main.ONOScli1.get_role("00001")
-
-        print main.ONOScli1.devices()
-        print main.ONOScli1.device_role("of:0000000000000001", "10.128.30.11", "standby")
-        time.sleep(1)
-        roles = main.ONOScli1.roles()
-        roles2 = main.ONOScli2.roles()
-        print roles
-        print roles2
-        print main.ONOScli1.get_role("00001")
-
-        print main.ONOScli1.devices()
-        print main.ONOScli1.device_role("of:0000000000000001", "10.128.30.11", "MASTER")
-        time.sleep(1)
-        roles = main.ONOScli1.roles()
-        roles2 = main.ONOScli2.roles()
-        print roles
-        print roles2
-        print main.ONOScli1.get_role("00001")
-        print main.ONOScli1.devices()
-
-    def CASE9(self, main):
-        '''
-        Bring Links down
-        '''
-        main.Mininet1.link(END1="s1", END2="s2", OPTION="down")
-        main.Mininet1.link(END1="s1", END2="s3", OPTION="down")
-        main.Mininet1.link(END1="s1", END2="s4", OPTION="down")
-
-
-
-
-######
-#jhall@onlab.us
-#andrew@onlab.us
-######
diff --git a/TestON/tests/MininetSlicing/MininetSlicing.ospk b/TestON/tests/MininetSlicing/MininetSlicing.ospk
deleted file mode 100644
index 8e2f32f..0000000
--- a/TestON/tests/MininetSlicing/MininetSlicing.ospk
+++ /dev/null
@@ -1,64 +0,0 @@
-CASE 1
-    NAME "Verifying 'SSH protocol' based slicing" 
-    
-    STEP "Deleting flowspace using 'removeFlowSpace'"
-    STORE ON FlowVisor1 DO removeFlowSpace USING "all" IN removeflowspace_result
-    ASSERT removeflowspace_result EQUALS main.TRUE ONPASS "Removed FlowSpace Successfully" ONFAIL "Failed to remove FlowSpace" 
-    
-    STEP "Showing connected devices using 'listDevices'"
-    STORE ON FlowVisor1 DO listDevices IN listdevices_result
-    ASSERT listdevices_result EQUALS main.TRUE ONPASS "Listed devices Successfully" ONFAIL "Failed to list the devices"
-
-    STEP "Verifying hosts reachability through ICMP traffic"
-    STORE ON Mininet1 DO pingHost USING src AS 'h1',target AS 'h4' IN ping_result
-    ASSERT ping_result EQUALS main.TRUE ONPASS "NO PACKET LOSS, HOST IS REACHABLE" ONFAIL "PACKET LOST, HOST IS NOT REACHABLE"  
-    
-    STEP "Showing the flowSpace USING 'listFlowSpace'"
-    STORE ON FlowVisor1 DO listFlowSpace IN listflowspace_result
-    STORE ON Mininet1 DO pingHost USING src AS 'h1',target AS 'h4' IN ping_result
-    ASSERT main.TRUE EQUALS main.TRUE ONPASS "Listed FlowSpace" ONFAIL "Failed to list the FlowSpace"
-   
-    STEP "Adding FlowSpace to create the slice of the Network"
-    INFO " Geeting the IP-Addresses of Hosts"
-    STORE ON Mininet1 DO getIPAddress USING 'h1' IN h1_ipaddress
-    STORE ON Mininet1 DO getIPAddress USING 'h4' IN h4_ipaddress 
-    
-    INFO " Geeting the MAC-Addresses of Hosts"  
-    STORE ON Mininet1 DO getMacAddress USING 'h1' IN h1_macaddress
-    STORE ON Mininet1 DO getMacAddress USING 'h4' IN h4_macaddress
-    
-    STORE ON FlowVisor1 DO addFlowSpace USING dl_src AS h1_macaddress,nw_dst AS h4_ipaddress IN addflowspace_result_1
-    ASSERT addflowspace_result_1 EQUALS main.TRUE ONPASS "Added FlowSpace Successfully" ONFAIL "Failed to add FlowSpace" 
-    
-    STORE ON FlowVisor1 DO addFlowSpace USING dl_src AS h4_macaddress,nw_dst AS h1_ipaddress IN addflowspace_result_2 
-    ASSERT addflowspace_result_2 EQUALS main.TRUE ONPASS "Added FlowSpace Successfully" ONFAIL "Failed to add FlowSpace" 
-    
-    STORE ON FlowVisor1 DO addFlowSpace USING nw_src AS h1_ipaddress IN addflowspace_result_3
-    STORE ON FlowVisor1 DO addFlowSpace USING nw_src AS h4_ipaddress IN addflowspace_result_3
-    
-    STORE ON FlowVisor1 DO addFlowSpace USING nw_src AS h1_ipaddress, tp_dst AS '22' IN addflowspace_result_3
-    ASSERT addflowspace_result_3 EQUALS main.TRUE ONPASS "Added FlowSpace Successfully" ONFAIL "Failed to add FlowSpace"
-    
-    STORE ON FlowVisor1 DO addFlowSpace USING nw_src AS h4_ipaddress,tp_dst AS '22' IN addflowspace_result_4
-    ASSERT addflowspace_result_4 EQUALS main.TRUE ONPASS "Added FlowSpace Successfully" ONFAIL "Failed to add FlowSpace" 
-    
-    STORE ON FlowVisor1 DO addFlowSpace USING nw_src AS h1_ipaddress,tp_src AS '22' IN addflowspace_result_5
-    ASSERT addflowspace_result_5 EQUALS main.TRUE ONPASS "Added FlowSpace Successfully" ONFAIL "Failed to add FlowSpace" 
-    
-    STORE ON FlowVisor1 DO addFlowSpace USING nw_src AS h4_ipaddress,tp_src AS '22' IN addflowspace_result_6
-    ASSERT addflowspace_result_6 EQUALS main.TRUE ONPASS "Added FlowSpace Successfully" ONFAIL "Failed to add FlowSpace"
-      
-    INFO "Showing the flowSpace USING 'listFlowSpace'"
-    STORE ON FlowVisor1 DO listFlowSpace IN listflowspace_result    
-
-    STEP "Verifying hosts reachability through ICMP traffic and Connectivity through SSH service"
-    STORE ON Mininet1 DO pingHost USING src AS 'h1',target AS 'h4' IN ping_result
-    ASSERT ping_result EQUALS main.TRUE ONPASS "NO PACKET LOSS, HOST IS REACHABLE" ONFAIL "PACKET LOST, HOST IS NOT REACHABLE"  
-
-    STORE ON Mininet1 DO verifySSH USING user_name AS CASE['destination_username'],ip_address AS CASE['destination_host'], pwd AS CASE['destination_password'], port AS CASE['destination_port'] IN ssh_result
-    ASSERT ssh_result EQUALS main.TRUE ONPASS "Failed to connect remote host throgh SSH" ONFAIL "Remote host connected throgh SSH "  
-     
-
-
-
-
diff --git a/TestON/tests/MininetSlicing/MininetSlicing.params b/TestON/tests/MininetSlicing/MininetSlicing.params
deleted file mode 100644
index c18e650..0000000
--- a/TestON/tests/MininetSlicing/MininetSlicing.params
+++ /dev/null
@@ -1,18 +0,0 @@
-<PARAMS>
-    <testcases> 1</testcases>
-    <mail> paxweb@paxterrasolutions.com</mail>
-    <CASE1>
-    
-        <dl_type> 0x800 </dl_type> 
-        <nw_proto> 6 </nw_proto>
-        <nw_src> 10.0.0.2 </nw_src>
-        <tp_dst> 22 </tp_dst>
-        <slice> SSH </slice> 
-        <permissions> 4 </permissions>
-        
-        <destination_host> 10.0.0.4 </destination_host>
-        <destination_username> openflow </destination_username>
-        <destination_password> openflow </destination_password>
-        <destination_port> 22 </destination_port>
-    </CASE1>
-</PARAMS>
\ No newline at end of file
diff --git a/TestON/tests/MininetSlicing/MininetSlicing.py b/TestON/tests/MininetSlicing/MininetSlicing.py
deleted file mode 100644
index 86b3ddc..0000000
--- a/TestON/tests/MininetSlicing/MininetSlicing.py
+++ /dev/null
@@ -1,71 +0,0 @@
-
-class MininetSlicing :
-
-    def __init__(self) :
-        self.default = ''
-
-    def CASE1(self,main) :
-
-        main.case("Verifying 'SSH protocol' based slicing")
-    
-        main.step("Deleting flowspace using 'removeFlowSpace'")
-        removeflowspace_result = main.FlowVisor1.removeFlowSpace("all")
-        utilities.assert_equals(expect=main.TRUE,actual=removeflowspace_result,onpass="Removed FlowSpace Successfully",onfail="Failed to remove FlowSpace")
-    
-        main.step("Showing connected devices using 'listDevices'")
-        listdevices_result = main.FlowVisor1.listDevices()
-        utilities.assert_equals(expect=main.TRUE,actual=listdevices_result,onpass="Listed devices Successfully",onfail="Failed to list the devices")
-    
-        main.step("Verifying hosts reachability through ICMP traffic")
-        ping_result = main.Mininet1.pingHost(src='h1',target='h4')
-        utilities.assert_equals(expect=main.TRUE,actual=ping_result,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOST, HOST IS NOT REACHABLE")
-    
-        main.step("Showing the flowSpace USING 'listFlowSpace'")
-        listflowspace_result = main.FlowVisor1.listFlowSpace()
-        ping_result = main.Mininet1.pingHost(src='h1',target='h4')
-    
-    
-        main.step("Adding FlowSpace to create the slice of the Network")
-        main.log.info(" Geeting the IP-Addresses of Hosts")
-        h1_ipaddress = main.Mininet1.getIPAddress('h1')
-        h4_ipaddress  = main.Mininet1.getIPAddress('h4')
-    
-        main.log.info(" Geeting the MAC-Addresses of Hosts"  )
-        h1_macaddress = main.Mininet1.getMacAddress('h1')
-        h4_macaddress = main.Mininet1.getMacAddress('h4')
-    
-        addflowspace_result_1 = main.FlowVisor1.addFlowSpace(dl_src=h1_macaddress,nw_dst=h4_ipaddress)
-        utilities.assert_equals(expect=main.TRUE,actual=addflowspace_result_1,onpass="Added FlowSpace Successfully",onfail="Failed to add FlowSpace")
-    
-        addflowspace_result_2  = main.FlowVisor1.addFlowSpace(dl_src=h4_macaddress,nw_dst=h1_ipaddress)
-        utilities.assert_equals(expect=main.TRUE,actual=addflowspace_result_2,onpass="Added FlowSpace Successfully",onfail="Failed to add FlowSpace")
-    
-        addflowspace_result_3 = main.FlowVisor1.addFlowSpace(nw_src=h1_ipaddress)
-        addflowspace_result_3 = main.FlowVisor1.addFlowSpace(nw_src=h4_ipaddress)
-    
-        addflowspace_result_3 = main.FlowVisor1.addFlowSpace(nw_src=h1_ipaddress, tp_dst='22')
-        utilities.assert_equals(expect=main.TRUE,actual=addflowspace_result_3,onpass="Added FlowSpace Successfully",onfail="Failed to add FlowSpace")
-    
-        addflowspace_result_4 = main.FlowVisor1.addFlowSpace(nw_src=h4_ipaddress,tp_dst='22')
-        utilities.assert_equals(expect=main.TRUE,actual=addflowspace_result_4,onpass="Added FlowSpace Successfully",onfail="Failed to add FlowSpace")
-    
-        addflowspace_result_5 = main.FlowVisor1.addFlowSpace(nw_src=h1_ipaddress,tp_src='22')
-        utilities.assert_equals(expect=main.TRUE,actual=addflowspace_result_5,onpass="Added FlowSpace Successfully",onfail="Failed to add FlowSpace")
-    
-        addflowspace_result_6 = main.FlowVisor1.addFlowSpace(nw_src=h4_ipaddress,tp_src='22')
-        utilities.assert_equals(expect=main.TRUE,actual=addflowspace_result_6,onpass="Added FlowSpace Successfully",onfail="Failed to add FlowSpace")
-    
-        main.log.info("Showing the flowSpace USING 'listFlowSpace'")
-        listflowspace_result     = main.FlowVisor1.listFlowSpace()
-    
-        main.step("Verifying hosts reachability through ICMP traffic and Connectivity through SSH service")
-        ping_result = main.Mininet1.pingHost(src='h1',target='h4')
-        utilities.assert_equals(expect=main.TRUE,actual=ping_result,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOST, HOST IS NOT REACHABLE")
-    
-        ssh_result = main.Mininet1.verifySSH(user_name=main.params['CASE1']['destination_username'],ip_address=main.params['CASE1']['destination_host'], pwd=main.params['CASE1']['destination_password'], port=main.params['CASE1']['destination_port'])
-        utilities.assert_equals(expect=main.TRUE,actual=ssh_result,onpass="Failed to connect remote host throgh SSH",onfail="Remote host connected throgh SSH ")
-    
-    
-    
-    
-    
\ No newline at end of file
diff --git a/TestON/tests/MininetSlicing/MininetSlicing.topo b/TestON/tests/MininetSlicing/MininetSlicing.topo
deleted file mode 100644
index 7a181d7..0000000
--- a/TestON/tests/MininetSlicing/MininetSlicing.topo
+++ /dev/null
@@ -1,43 +0,0 @@
-<TOPOLOGY>
-    <COMPONENT>          
-        <FlowVisor1>
-            <host>192.168.56.101</host>
-            <user> openflow </user>
-            <fvadmin_pwd></fvadmin_pwd>
-            <password>openflow</password>
-            <type>FlowVisorDriver</type>
-            <COMPONENTS>
-            </COMPONENTS>
-               
-        </FlowVisor1>   
-        
-        <Mininet1>
-            <host>192.168.56.101</host>
-            <user> openflow</user>
-            <password> openflow</password>
-            <type>MininetCliDriver</type>
-            <COMPONENTS>
-                # Specify the Option for mininet
-                <topo> single</topo>
-                <topocount>3</topocount>
-                <switch> ovsk </switch>
-                <controller> remote </controller>
-             </COMPONENTS>   
-        </Mininet1>        
-        
-        <POX2>
-            <host> 192.168.56.102 </host>
-            <user>  openflow </user>
-            <password> openflow </password>
-            <type> PoxCliDriver </type>
-            <test_target> 1 </test_target>
-            <COMPONENTS>
-                <pox_lib_location> /home/openflow/pox/  </pox_lib_location>
-                <samples.of_tutorial></samples.of_tutorial>
-            </COMPONENTS>
-        </POX2>
-    
-               
-    </COMPONENT>
-    
-</TOPOLOGY>
\ No newline at end of file
diff --git a/TestON/tests/MininetSlicing/__init__.py b/TestON/tests/MininetSlicing/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/TestON/tests/MininetSlicing/__init__.py
+++ /dev/null
diff --git a/TestON/tests/MininetTest/MininetTest.params b/TestON/tests/MininetTest/MininetTest.params
deleted file mode 100644
index 0f798b1..0000000
--- a/TestON/tests/MininetTest/MininetTest.params
+++ /dev/null
@@ -1,23 +0,0 @@
-<PARAMS>
-    <testcases>[1,2]</testcases>
-    <mail>anilkumar.s@paxterrasolutions.com,raghavkashyap@paxterrasolutions.com</mail>
-    <CASE1> 
-        <destination> h2</destination>
-        <STEP1>
-            <host> h2 </host>
-        </STEP1>
-    </CASE1>
-    <SET1>
-        <begin>
-            <one>s1</one>
-            <two>s1</two>
-            <three>s3</three> 
-        </begin>
-        <end>
-            <one>s2</one>
-            <two>s3</two>
-            <three>s4</three> 
-        </end>
-    </SET1>
-        
-</PARAMS>      
diff --git a/TestON/tests/MininetTest/MininetTest.py b/TestON/tests/MininetTest/MininetTest.py
deleted file mode 100644
index 72fab6e..0000000
--- a/TestON/tests/MininetTest/MininetTest.py
+++ /dev/null
@@ -1,24 +0,0 @@
-
-class MininetTest :
-
-    def __init__(self) :
-        self.default = ''
-
-    def CASE1(self,main) :
-
-        main.case("Testing the configuration of the host")
-        main.step("Host IP Checking using checkIP")
-        main.ONOS1.start()
-        result = main.Mininet1.checkIP(main.params['CASE1']['destination'])
-        main.step("Verifying the result")
-        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Host h2 IP address configured",onfail="Host h2 IP address didn't configured")
-    
-    def CASE2(self,main) :
-
-        main.case("Testing Reachabilty of all the hosts")
-        main.step("Checking Hosts reachability by using pingall")
-        result = main.Mininet1.pingall()
-        main.step("Verifying the result")
-        for source in  main.params['SET1']['begin']:
-            main.log.info(str(main.params['SET1']['begin'][source]))
-        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="All hosts are reacchable",onfail="Hosts are not reachable")
diff --git a/TestON/tests/MininetTest/MininetTest.topo b/TestON/tests/MininetTest/MininetTest.topo
deleted file mode 100644
index 21d54de..0000000
--- a/TestON/tests/MininetTest/MininetTest.topo
+++ /dev/null
@@ -1,81 +0,0 @@
-<TOPOLOGY>
-    <COMPONENT>
-        <Zookeeper1>
-            <host>10.128.100.1</host>
-            <user>admin</user>
-            <password></password>
-            <type>ZookeeperCliDriver</type>
-            <connect_order>1</connect_order>
-        </Zookeeper1>
-
-        <Cassandra1>
-            <host>10.128.100.1</host>
-            <user>admin</user>
-            <password></password>
-            <type>CassandraCliDriver</type>
-            <connect_order>2</connect_order>
-        </Cassandra1>
-        <Cassandra2>
-            <host>10.128.100.4</host>
-            <user>admin</user>
-            <password></password>
-            <type>CassandraCliDriver</type>
-            <connect_order>3</connect_order>
-        </Cassandra2>
-        <Cassandra3>
-            <host>10.128.100.5</host>
-            <user>admin</user>
-            <password></password>
-            <type>CassandraCliDriver</type>
-            <connect_order>4</connect_order>
-        </Cassandra3>
-        <Cassandra4>
-            <host>10.128.100.6</host>
-            <user>admin</user>
-            <password></password>
-            <type>CassandraCliDriver</type>
-            <connect_order>5</connect_order>
-        </Cassandra4>
-
-        <ONOS1>
-            <host>10.128.100.1</host>
-            <user>admin</user>
-            <password></password>
-            <type>OnosCliDriver</type>
-            <connect_order>6</connect_order>
-        </ONOS1>
-        <ONOS2>
-            <host>10.128.100.4</host>
-            <user>admin</user>
-            <password></password>
-            <type>OnosCliDriver</type>
-            <connect_order>7</connect_order>
-        </ONOS2>
-        <ONOS3>
-            <host>10.128.100.5</host>
-            <user>admin</user>
-            <password></password>
-            <type>OnosCliDriver</type>
-            <connect_order>8</connect_order>
-        </ONOS3>
-        <ONOS4>
-            <host>10.128.100.6</host>
-            <user>admin</user>
-            <password></password>
-            <type>OnosCliDriver</type>
-            <connect_order>9</connect_order>
-        </ONOS4>
-        <Mininet1>
-            <host>10.128.100.11</host>
-            <user>admin</user>
-            <password></password>
-            <type>MininetCliDriver</type>
-            <COMPONENTS>
-                # Specify the Option for mininet
-                <arg1> </arg1>
-                <arg2> </arg2>
-                <controller> none  </controller>
-             </COMPONENTS>
-        </Mininet1>
-   </COMPONENT>
-</TOPOLOGY>
diff --git a/TestON/tests/MininetTest/__init__.py b/TestON/tests/MininetTest/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/TestON/tests/MininetTest/__init__.py
+++ /dev/null
diff --git a/TestON/tests/ONOSNextTest/ONOSNextTest.params b/TestON/tests/ONOSNextTest/ONOSNextTest.params
deleted file mode 100755
index d600eae..0000000
--- a/TestON/tests/ONOSNextTest/ONOSNextTest.params
+++ /dev/null
@@ -1,20 +0,0 @@
-<PARAMS>
-    
-    <testcases>1,5</testcases>
-
-    #Environment variables
-    <ENV>
-        <cellName>driver_test</cellName>
-    </ENV>
-
-    <CTRL>
-        <ip1>10.128.174.1</ip1>
-        <port1>6633</port1>
-    </CTRL>
-
-    <GIT>
-        <autoPull>off</autoPull>
-        <checkout>master</checkout>
-    </GIT>
-
-</PARAMS>
diff --git a/TestON/tests/ONOSNextTest/ONOSNextTest.py b/TestON/tests/ONOSNextTest/ONOSNextTest.py
deleted file mode 100755
index 3496771..0000000
--- a/TestON/tests/ONOSNextTest/ONOSNextTest.py
+++ /dev/null
@@ -1,335 +0,0 @@
-
-#Testing the basic functionality of ONOS Next
-#For sanity and driver functionality excercises only.
-
-import time
-import sys
-import os
-import re
-
-class ONOSNextTest:
-    def __init__(self):
-        self.default = ''
-
-    def CASE1(self, main):
-        '''
-        Startup sequence:
-        git pull
-        mvn clean install
-        onos-package
-        cell <name>
-        onos-verify-cell
-        onos-install -f
-        onos-wait-for-start
-        '''
-        import time
-
-        cell_name = main.params['ENV']['cellName']
-
-        ONOS1_ip = main.params['CTRL']['ip1']
-        ONOS1_port = main.params['CTRL']['port1']
-        
-        git_pull_trigger = main.params['GIT']['autoPull']
-        git_checkout_branch = main.params['GIT']['checkout']
-
-        main.case("Setting up test environment")
-        
-        main.step("Creating cell file")
-        #params: (bench ip, cell name, mininet ip, *onos ips)
-        cell_file_result = main.ONOSbench.create_cell_file(
-                "10.128.20.10", "temp_cell_2", "10.128.10.90",
-                "onos-core-trivial,onos-app-fwd",
-                "10.128.174.1")
-
-        main.step("Applying cell variable to environment")
-        #cell_result = main.ONOSbench.set_cell(cell_name)
-        cell_result = main.ONOSbench.set_cell("temp_cell_2")
-        verify_result = main.ONOSbench.verify_cell()
-       
-        if git_pull_trigger == 'on':
-            main.step("Git checkout and pull master")
-            main.ONOSbench.git_checkout(git_checkout_branch)
-            git_pull_result = main.ONOSbench.git_pull()
-        else:
-            main.log.info("Git checkout and pull skipped by config")
-            git_pull_result = main.TRUE
-
-        main.step("Using mvn clean & install")
-        #clean_install_result = main.ONOSbench.clean_install()
-        clean_install_result = main.TRUE
-
-        main.step("Creating ONOS package")
-        package_result = main.ONOSbench.onos_package()
-
-        main.step("Installing ONOS package")
-        onos_install_result = main.ONOSbench.onos_install()
-        onos1_isup = main.ONOSbench.isup()
-   
-        main.step("Starting ONOS service")
-        start_result = main.ONOSbench.onos_start(ONOS1_ip)
-
-        case1_result = (clean_install_result and package_result and\
-                cell_result and verify_result and onos_install_result and\
-                onos1_isup and start_result )
-        utilities.assert_equals(expect=main.TRUE, actual=case1_result,
-                onpass="Test startup successful",
-                onfail="Test startup NOT successful")
-
-        time.sleep(10)
-
-    def CASE11(self, main):
-        '''
-        Cleanup sequence:
-        onos-service <node_ip> stop
-        onos-uninstall
-
-        TODO: Define rest of cleanup
-        
-        '''
-
-        ONOS1_ip = main.params['CTRL']['ip1']
-
-        main.case("Cleaning up test environment")
-
-        main.step("Testing ONOS kill function")
-        kill_result = main.ONOSbench.onos_kill(ONOS1_ip)
-
-        main.step("Stopping ONOS service")
-        stop_result = main.ONOSbench.onos_stop(ONOS1_ip)
-
-        main.step("Uninstalling ONOS service") 
-        uninstall_result = main.ONOSbench.onos_uninstall()
-
-    def CASE3(self, main):
-        '''
-        Test 'onos' command and its functionality in driver
-        '''
-        
-        ONOS1_ip = main.params['CTRL']['ip1']
-
-        main.case("Testing 'onos' command")
-
-        main.step("Sending command 'onos -w <onos-ip> system:name'")
-        cmdstr1 = "system:name"
-        cmd_result1 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr1) 
-        main.log.info("onos command returned: "+cmd_result1)
-
-        main.step("Sending command 'onos -w <onos-ip> onos:topology'")
-        cmdstr2 = "onos:topology"
-        cmd_result2 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr2)
-        main.log.info("onos command returned: "+cmd_result2)
-        
-        main.step("Testing check_status")
-        check_status_results =  main.ONOSbench.check_status(ONOS1_ip, 4, 6)
-        main.log.info("Results of check_status " + str(check_status_results))
-
-        main.step("Sending command 'onos -w <onos-ip> bundle:list'")
-        cmdstr3 = "bundle:list"
-        cmd_result3 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr3)
-        main.log.info("onos command returned: "+cmd_result3)
-        case3_result = (cmd_result1 and cmd_result2 and\
-                check_status_results and cmd_result3 )
-        utilities.assert_equals(expect=main.TRUE, actual=case3_result,
-                onpass="Test case 3 successful",
-                onfail="Test case 3 NOT successful")
-
-    def CASE4(self, main):
-        import re
-        import time
-        main.case("Pingall Test(No intents are added)")
-        main.step("Assigning switches to controllers")
-        for i in range(1,5): #1 to (num of switches +1)
-            main.Mininet1.assign_sw_controller(sw=str(i), 
-                    ip1=ONOS1_ip, port1=ONOS1_port)
-        switch_mastership = main.TRUE
-        for i in range (1,5):
-            response = main.Mininet1.get_sw_controller("s"+str(i))
-            print("Response is " + str(response))
-            if re.search("tcp:"+ONOS1_ip,response):
-                switch_mastership = switch_mastership and main.TRUE
-            else:
-                switch_mastership = main.FALSE
-
-        #REACTIVE FWD test
-        main.step("Pingall")
-        ping_result = main.FALSE
-        while ping_result == main.FALSE:
-            time1 = time.time()
-            ping_result = main.Mininet1.pingall()
-            time2 = time.time()
-            print "Time for pingall: %2f seconds" % (time2 - time1)
-      
-        case4_result = switch_mastership and ping_result
-        utilities.assert_equals(expect=main.TRUE, actual=case4_result,
-                onpass="Pingall Test successful",
-                onfail="Pingall Test NOT successful")
-
-    def CASE5(self, main):
-        '''
-        Test the ONOS-cli functionality
-        
-        Below are demonstrations of what the 
-        ONOS cli driver functions can be used for.
-        '''
-        import time
-        import json
-
-        cell_name = main.params['ENV']['cellName']
-        ONOS1_ip = main.params['CTRL']['ip1']
-        
-        main.case("Testing the ONOS-cli")
-        
-        main.step("Set cell for ONOS-cli environment")
-        #main.ONOScli.set_cell(cell_name)
-        main.ONOScli.set_cell("temp_cell_2")
-
-        main.step("Start ONOS-cli")
-        main.ONOScli.start_onos_cli(ONOS1_ip)
-
-        main.step("issue command: onos:topology")
-        topology_obj = main.ONOScli.topology()
-
-        main.step("issue various feature:install <str> commands")
-        #main.ONOScli.feature_install("onos-app-fwd")
-        #main.ONOScli.feature_install("onos-rest")
-
-        main.step("Add a bad node")
-        node_result = main.ONOScli.add_node("111", "10.128.20.")
-        if node_result == main.TRUE:
-            main.log.info("Node successfully added")
-
-        main.step("Add a correct node")
-        node_result = main.ONOScli.add_node("111", "10.128.174.2")
-
-        main.step("Assign switches and list devices")
-        for i in range(1,8):
-            main.Mininet2.handle.sendline("sh ovs-vsctl set-controller s"+str(i)+
-                    " tcp:10.128.174.1")
-            main.Mininet2.handle.expect("mininet>")
-        #Need to sleep to allow switch add processing
-        time.sleep(5)
-        list_result = main.ONOScli.devices(json_format=False)
-        main.log.info(list_result)
-
-        main.step("Get all devices id")
-        devices_id_list = main.ONOScli.get_all_devices_id()
-        main.log.info(devices_id_list)
-
-        main.step("Get path and cost between device 1 and 7")
-        (path, cost) = main.ONOScli.paths(devices_id_list[0], devices_id_list[6])
-        main.log.info("Path: "+str(path))
-        main.log.info("Cost: "+str(cost))
-
-        main.step("Get nodes currently visible")
-        nodes_str = main.ONOScli.nodes()
-        main.log.info(nodes_str)
-
-        main.step("Get all nodes id's")
-        node_id_list = main.ONOScli.get_all_nodes_id()
-        main.log.info(node_id_list)
-
-        main.step("Set device "+str(devices_id_list[0])+" to role: standby")
-        device_role_result = main.ONOScli.device_role(
-                devices_id_list[0], node_id_list[0], "standby")
-        if device_role_result == main.TRUE:
-            main.log.report("Device role successfully set")
-
-        main.step("Revert device role to master")
-        device_role = main.ONOScli.device_role(
-                devices_id_list[0], node_id_list[0], "master")
-
-        main.step("Check devices / role again")
-        dev_result = main.ONOScli.devices(json_format=False)
-        main.log.info(dev_result)
-       
-        #Sample steps to push intents ***********
-        # * Obtain host id in ONOS format 
-        # * Push intents
-        main.step("Get list of hosts from Mininet")
-        host_list = main.Mininet2.get_hosts()
-        main.log.info(host_list)
-
-        main.step("Get host list in ONOS format")
-        host_onos_list = main.ONOScli.get_hosts_id(host_list)
-        main.log.info(host_onos_list)
-
-        time.sleep(5)
-
-        #We must use ping from hosts we want to add intents from 
-        #to make the hosts talk
-        #main.Mininet2.handle.sendline("\r")
-        #main.Mininet2.handle.sendline("h4 ping 10.1.1.1 -c 1 -W 1")
-        #time.sleep(3)
-        #main.Mininet2.handle.sendline("h5 ping 10.1.1.1 -c 1 -W 1")
-        #time.sleep(5)
-
-        main.ONOScli.feature_install("onos-app-fwd")
-        
-        main.Mininet2.pingall()
-
-        time.sleep(5)
-
-        main.step("Get hosts")
-        main.ONOScli.handle.sendline("hosts")
-        main.ONOScli.handle.expect("onos>")
-        hosts = main.ONOScli.handle.before
-        main.log.info(hosts)
-
-        main.step("Install host-to-host-intents")
-        intent_install1 = main.ONOScli.add_host_intent(
-                host_onos_list[0], host_onos_list[1])
-        intent_install2 = main.ONOScli.add_host_intent(
-                host_onos_list[2], host_onos_list[3])
-        intent_install3 = main.ONOScli.add_host_intent(
-                host_onos_list[4], host_onos_list[5])
-
-        main.log.info(intent_install1)
-        main.log.info(intent_install2)
-        main.log.info(intent_install3)
-
-        main.step("Get intents installed on ONOS")
-        get_intent_result = main.ONOScli.intents()
-        main.log.info(get_intent_result)
-        #****************************************
-
-        #Sample steps to delete intents ********
-        main.step("Get all intent id's")
-        intent_id = main.ONOScli.get_all_intents_id()
-        main.log.info(intent_id)
-
-        main.step("Remove specified intent id: "+str(intent_id[0]))
-        intent_result = main.ONOScli.remove_intent(intent_id[0])
-        main.log.info(intent_result)
-
-        main.step("Check installed intents again")
-        get_intent_result = main.ONOScli.intents()
-        main.log.info(get_intent_result)
-        #***************************************
-
-        #Sample steps to add point-to-point intents*
-        main.step("Add point-to-point intents")
-        ptp_intent_result = main.ONOScli.add_point_intent(
-                devices_id_list[0], 1, devices_id_list[1], 2)
-        if ptp_intent_result == main.TRUE:
-            get_intent_result = main.ONOScli.intents()
-            main.log.info("Point to point intent install successful")
-            main.log.info(get_intent_result)
-        #*******************************************
-
-        main.step("Print intents in json format")
-        intents = main.ONOScli.intents(json_format = True)
-        main.log.info(intents)
-
-        main.step("Add eth options in point-to-point intent")
-        ptp_eth = main.ONOScli.add_point_intent(
-                devices_id_list[2], 1, devices_id_list[3], 2,
-                ethSrc = "00:02", ethDst = "00:03")
-        main.log.info(ptp_eth)
-
-        main.step("Print intents with eth options")
-        intents = main.ONOScli.intents()
-        main.log.info(intents)
-######
-#jhall@onlab.us
-#andrew@onlab.us
-######
diff --git a/TestON/tests/ONOSNextTest/ONOSNextTest.topo b/TestON/tests/ONOSNextTest/ONOSNextTest.topo
deleted file mode 100755
index 0c84cc7..0000000
--- a/TestON/tests/ONOSNextTest/ONOSNextTest.topo
+++ /dev/null
@@ -1,61 +0,0 @@
-<TOPOLOGY>
-    <COMPONENT>
-
-        <ONOSbench>
-            <host>10.128.20.10</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>OnosDriver</type>
-            <connect_order>1</connect_order>
-            <COMPONENTS> </COMPONENTS>
-        </ONOSbench>
-
-        <ONOScli>
-            <host>10.128.20.10</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>OnosCliDriver</type>
-            <connect_order>2</connect_order>
-            <COMPONENTS> </COMPONENTS>
-        </ONOScli>
-
-        <ONOS1>
-            <host>10.128.174.1</host>
-            <user>sdn</user>
-            <password>rocks</password>
-            <type>OnosDriver</type>
-            <connect_order>3</connect_order>
-            <COMPONENTS> </COMPONENTS>
-        </ONOS1>
-
-        <Mininet1>
-            <host>10.128.10.90</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>MininetCliDriver</type>
-            <connect_order>4</connect_order>
-            <COMPONENTS>
-                #Specify the Option for mininet
-                <arg1> --topo tree,2,3</arg1>
-                <arg2> </arg2>
-                <arg3> </arg3>
-                <controller> remote </controller>
-            </COMPONENTS>
-        </Mininet1>
-
-        <Mininet2>
-            <host>10.128.10.91</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>MininetCliDriver</type>
-            <connect_order>5</connect_order>
-            <COMPONENTS> 
-                <arg1> --custom topo-intentTPtest.py </arg1>
-                <arg2> --arp --mac</arg2>
-                <arg3> --topo mytopo</arg3>
-                <controller> remote </controller>
-            </COMPONENTS>
-        </Mininet2>
-
-    </COMPONENT>
-</TOPOLOGY>
diff --git a/TestON/tests/ONOSNextTest/__init__.py b/TestON/tests/ONOSNextTest/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/TestON/tests/ONOSNextTest/__init__.py
+++ /dev/null
diff --git a/TestON/tests/OnosCHO/OnosCHO.params b/TestON/tests/OnosCHO/OnosCHO.params
new file mode 100644
index 0000000..7856a28
--- /dev/null
+++ b/TestON/tests/OnosCHO/OnosCHO.params
@@ -0,0 +1,69 @@
+<PARAMS>
+    #CHO sequence : 1,2,3,[4,5,6,5,7,8,5,10,5,9,5,7,8,5,10,5]*2
+    # 1. ONOS brinup Test case
+    # 2. Assign and Balance all Mininet switches across controllers
+    # 3. Collect reference toplogy for topo compare
+    # 4. Enable Reactive forwarding, Verify ping all and disable onos-app-fwd
+    # 5. Compare curent topoology with reference
+    # 6. Install 300 host intents and verify ping all
+    # 7. Randomly bring some core links down and verify pingall
+    # 8. Bring core links Up that were down and verify pingall
+    # 9. Install 114 point intents and verify ping all
+    # 10. Remove all intents on ONOS
+    # 1,2,3,[4,5,6,5,7,8,5,10,5,9,5,7,8,5,10,5]*2
+
+    <testcases>1,2,3,9</testcases>
+    <ENV>
+        <cellName>choTest5</cellName>
+    </ENV>
+    <GIT>
+        #autoPull 'on' or 'off'
+        <autoPull>on</autoPull>
+        <branch>master</branch>
+    </GIT>
+    <CTRL>
+	<numCtrl>5</numCtrl>
+        <ip1>10.128.40.41</ip1>
+	<port1>6633</port1>
+	<ip2>10.128.40.42</ip2>
+	<port2>6633</port2>
+	<ip3>10.128.40.43</ip3>
+	<port3>6633</port3>
+        <ip4>10.128.40.44</ip4>
+	<port4>6633</port4>
+	<ip5>10.128.40.45</ip5>
+	<port5>6633</port5>
+    </CTRL>
+    <HOSTS>
+	<startMAC>00:00:00:00:00:01</startMAC>
+	<endMAC>00:00:00:00:00:19</endMAC>
+    </HOSTS>
+    <ONOSTOPO>
+	<numDevices>25</numDevices>
+	<numLinks>114</numLinks>
+	<numHosts>25</numHosts>
+	<numIntents>300</numIntents>
+	<numPaths>1360</numPaths>
+    </ONOSTOPO>
+    <CORELINKS>
+        <toggleLinks>3</toggleLinks>
+	
+	<linkS3a>s3</linkS3a>
+	<linkS3b>s1,s4,s7,s10,s16,s17,s18,s21,s22</linkS3b>
+	#######s1,s4,s7,s10,s16,s17,s18,s21,s22########
+	
+	<linkS14a>s14</linkS14a>
+	<linkS14b>s6,s9,s10,s11,s12,s13,s16,s17,s23</linkS14b>
+	########s6,s9,s10,s11,s12,s13,s16,s17,s18,s23########
+	
+	<linkS18a>s18</linkS18a>
+	<linkS18b>s14,s16,s17,s19,s20,s21,s22,s23</linkS18b>
+	#######s3,s14,s16,s17,s19,s20,s21,s22,s23########
+    </CORELINKS>
+
+    <timers>
+        <LinkDiscovery>5</LinkDiscovery>
+        <SwitchDiscovery>31</SwitchDiscovery>
+    </timers>
+
+</PARAMS>
diff --git a/TestON/tests/OnosCHO/OnosCHO.py b/TestON/tests/OnosCHO/OnosCHO.py
new file mode 100644
index 0000000..3a838fa
--- /dev/null
+++ b/TestON/tests/OnosCHO/OnosCHO.py
@@ -0,0 +1,596 @@
+import time
+import sys
+import os
+import re
+import time
+import json
+import itertools
+
+class OnosCHO:
+    def __init__(self):
+        self.default = ''
+        global deviceDPIDs
+        global hostMACs
+        global deviceLinks
+        global deviceActiveLinksCount
+        global devicePortsEnabledCount
+        global installedIntents
+        global randomLink1, randomLink2, randomLink3, numSwitches, numLinks
+    def CASE1(self, main):
+        '''
+        Startup sequence:
+        git pull
+        mvn clean install
+        onos-package
+        cell <name>
+        onos-verify-cell
+        onos-install -f
+        onos-wait-for-start
+        '''
+        import time
+        cell_name = main.params['ENV']['cellName']
+        git_pull = main.params['GIT']['autoPull']
+        numCtrls = main.params['CTRL']['numCtrl']
+        git_branch = main.params['GIT']['branch']
+
+        main.case("Set up test environment")
+        main.log.report("Set up test environment")
+        main.log.report("_______________________")
+                
+        main.step("Git checkout and pull "+git_branch)
+        if git_pull == 'on':
+            checkout_result = main.ONOSbench.git_checkout(git_branch)
+            pull_result = main.ONOSbench.git_pull()
+            cp_result = (checkout_result and pull_result)
+        else:
+            checkout_result = main.TRUE
+            pull_result = main.TRUE
+            main.log.info("Skipped git checkout and pull")
+            cp_result = (checkout_result and pull_result)
+        utilities.assert_equals(expect=main.TRUE, actual=cp_result,
+                onpass="Test step PASS",
+                onfail="Test step FAIL")
+		
+        main.step("mvn clean & install")
+        mvn_result = main.ONOSbench.clean_install()
+        utilities.assert_equals(expect=main.TRUE, actual=mvn_result,
+                onpass="Test step PASS",
+                onfail="Test step FAIL")
+
+        main.ONOSbench.get_version(report=True)
+
+        main.step("Apply Cell environment for ONOS")
+        cell_result = main.ONOSbench.set_cell(cell_name)
+        utilities.assert_equals(expect=main.TRUE, actual=cell_result,
+                onpass="Test step PASS",
+                onfail="Test step FAIL")
+
+        main.step("Create ONOS package")
+        packageResult = main.ONOSbench.onos_package()
+        utilities.assert_equals(expect=main.TRUE, actual=packageResult,
+                onpass="Test step PASS",
+                onfail="Test step FAIL")
+
+        main.step("Uninstall ONOS package on all Nodes")
+        uninstallResult=main.TRUE
+        for i in range(1,int(numCtrls)+1):
+            ONOS_ip = main.params['CTRL']['ip'+str(i)]
+            main.log.info("Unintsalling package on ONOS Node IP: "+ONOS_ip)
+            u_result= main.ONOSbench.onos_uninstall(ONOS_ip)
+            utilities.assert_equals(expect=main.TRUE, actual=u_result,
+                onpass="Test step PASS",
+                onfail="Test step FAIL")
+            uninstallResult=(uninstallResult and u_result)
+
+        main.step("Removing copy-cat logs from ONOS nodes")
+        main.ONOSbench.onos_remove_raft_logs()
+
+        main.step("Install ONOS package on all Nodes")
+        installResult=main.TRUE
+        for i in range(1,int(numCtrls)+1):
+            ONOS_ip = main.params['CTRL']['ip'+str(i)]
+            main.log.info("Intsalling package on ONOS Node IP: "+ONOS_ip)
+            i_result= main.ONOSbench.onos_install(node=ONOS_ip)
+            utilities.assert_equals(expect=main.TRUE, actual=i_result,
+                onpass="Test step PASS",
+                onfail="Test step FAIL")
+            installResult=(installResult and i_result)
+
+        main.step("Verify ONOS nodes UP status")
+        statusResult=main.TRUE
+        for i in range(1,int(numCtrls)+1):
+            ONOS_ip = main.params['CTRL']['ip'+str(i)]
+            main.log.info("ONOS Node "+ONOS_ip+" status:")
+            onos_status = main.ONOSbench.onos_status(node=ONOS_ip)
+            utilities.assert_equals(expect=main.TRUE, actual=onos_status,
+                onpass="Test step PASS",
+                onfail="Test step FAIL")
+            statusResult=(statusResult and onos_status)   
+
+        main.step("Start ONOS CLI on all nodes")
+        cliResult = main.TRUE
+        time.sleep(15) # need to wait here for sometime. This will be removed once ONOS is stable enough
+        for i in range(1,int(numCtrls)+1):
+            ONOS_ip = main.params['CTRL']['ip'+str(i)]
+            ONOScli = 'ONOScli'+str(i)
+            main.log.info("ONOS Node "+ONOS_ip+" cli start:")
+            exec "startcli=main."+ONOScli+".start_onos_cli(ONOS_ip)"
+            utilities.assert_equals(expect=main.TRUE, actual=startcli,
+                onpass="Test step PASS",
+                onfail="Test step FAIL")
+            cliResult = (cliResult and startcli) 
+
+        case1Result = (cp_result and cell_result 
+                and packageResult and installResult and statusResult and cliResult)
+        utilities.assert_equals(expect=main.TRUE, actual=case1Result,
+                onpass="Set up test environment PASS",
+                onfail="Set up test environment FAIL")
+
+    def CASE2(self, main):
+        ''' 
+        This test script still needs more refactoring
+        '''
+        import re
+        import time
+        import copy
+        numCtrls = main.params['CTRL']['numCtrl']
+        ONOS1_ip = main.params['CTRL']['ip1']
+        ONOS2_ip = main.params['CTRL']['ip2']
+        ONOS3_ip = main.params['CTRL']['ip3']
+        ONOS4_ip = main.params['CTRL']['ip4']
+        ONOS5_ip = main.params['CTRL']['ip5']
+        ONOS1_port = main.params['CTRL']['port1']
+        ONOS2_port = main.params['CTRL']['port2']
+        ONOS3_port = main.params['CTRL']['port3']
+        ONOS4_port = main.params['CTRL']['port4']
+        ONOS5_port = main.params['CTRL']['port5']
+
+        numCtrls = main.params['CTRL']['numCtrl']
+        main.log.report("Assign and Balance all Mininet switches across controllers")
+        main.log.report("_________________________________________________________")
+        time.sleep(15) # need to wait here for sometime. This will be removed once ONOS is stable enough
+        main.case("Assign and Balance all Mininet switches across controllers")
+        main.step("Assign switches to controllers")
+        for i in range(1,26): #1 to (num of switches +1)
+            main.Mininet1.assign_sw_controller(sw=str(i),count=int(numCtrls), 
+                    ip1=ONOS1_ip, port1=ONOS1_port,
+                    ip2=ONOS2_ip, port2=ONOS2_port,
+		            ip3=ONOS3_ip, port3=ONOS3_port, ip4=ONOS4_ip, port4=ONOS4_port, 
+			    ip5=ONOS5_ip, port5=ONOS5_port)
+
+        switch_mastership = main.TRUE
+        for i in range (1,26):
+            response = main.Mininet1.get_sw_controller("s"+str(i))
+            print("Response is " + str(response))
+            if re.search("tcp:"+ONOS1_ip,response):
+                switch_mastership = switch_mastership and main.TRUE
+            else:
+                switch_mastership = main.FALSE
+
+        if switch_mastership == main.TRUE:
+            main.log.report("Controller assignment successfull")
+        else:
+             main.log.report("Controller assignment failed")
+        time.sleep(5)
+
+        main.step("Balance devices across controllers")
+        for i in range(int(numCtrls)):
+            balanceResult = main.ONOScli1.balance_masters()
+            time.sleep(3) # giving some breathing time for ONOS to complete re-balance
+
+        utilities.assert_equals(expect=main.TRUE, actual=balanceResult,
+                onpass="Assign and Balance devices test PASS",
+                onfail="Assign and Balance devices test FAIL")
+
+    def CASE3(self,main) :
+        ''' 
+        This Test case will be extended to collect and store more data related
+        ONOS state.
+        '''
+        import re
+        import copy
+        deviceDPIDs = []
+        hostMACs = []
+        deviceLinks = []
+        deviceActiveLinksCount = []
+        devicePortsEnabledCount = []
+
+        main.log.report("Collect and Store topology details from ONOS before running any Tests")
+        main.log.report("____________________________________________________________________")        
+        main.case ("Collect and Store Topology Deatils from ONOS")
+
+        main.step("Collect and store current number of switches and links")
+        topology_output = main.ONOScli1.topology()
+        topology_result = main.ONOSbench.get_topology(topology_output)
+        numSwitches = topology_result['devices']
+        numLinks = topology_result['links']
+        main.log.info("Currently there are %s switches and %s links"  %(str(numSwitches), str(numLinks)))
+
+        main.step("Store Device DPIDs")
+        for i in range(1,26):
+            deviceDPIDs.append("of:00000000000000"+format(i, '02x'))
+        print "Device DPIDs in Store: \n", str(deviceDPIDs)
+
+        main.step("Store Host MACs")
+        for i in range(1,26):
+            hostMACs.append("00:00:00:00:00:"+format(i, '02x')+"/-1")
+        print "Host MACs in Store: \n", str(hostMACs)
+
+        main.step("Collect and store all Devices Links")
+        linksResult = main.ONOScli1.links(json_format=False)
+        ansi_escape = re.compile(r'\x1b[^m]*m')
+        linksResult = ansi_escape.sub('', linksResult)
+        linksResult = linksResult.replace(" links","").replace("\r\r","")
+        linksResult=linksResult.splitlines()
+        linksResult = linksResult[1:]
+        deviceLinks = copy.copy(linksResult)
+        print "Device Links Stored: \n", str(deviceLinks)
+        print "Length of Links Store", len(deviceLinks) # this will be asserted to check with the params provided count of links
+
+        main.step("Collect and store each Device ports enabled Count")
+        for i in range(1,26):
+            portResult = main.ONOScli1.getDevicePortsEnabledCount("of:00000000000000"+format(i, '02x'))
+            portTemp = re.split(r'\t+', portResult)
+            portCount = portTemp[1].replace("\r\r\n\x1b[32m","")
+            devicePortsEnabledCount.append(portCount)
+        print "Device Enabled Port Counts Stored: \n", str(devicePortsEnabledCount)
+
+        main.step("Collect and store each Device active links Count")
+        for i in range(1,26):
+            linkCountResult = main.ONOScli1.getDeviceLinksActiveCount("of:00000000000000"+format(i, '02x'))
+            linkCountTemp = re.split(r'\t+', linkCountResult)
+            linkCount = linkCountTemp[1].replace("\r\r\n\x1b[32m","")
+            deviceActiveLinksCount.append(linkCount)
+        print "Device Active Links Count Stored: \n", str(deviceActiveLinksCount)
+
+        caseResult = main.TRUE  # just returning TRUE for now as this one just collects data
+        utilities.assert_equals(expect=main.TRUE, actual=case1Result,
+                onpass="Saving ONOS topology data test PASS",
+                onfail="Saving ONOS topology data test FAIL")
+
+    def CASE4(self,main) :
+        ''' 
+        Enable onos-app-fwd, Verify Reactive forwarding through ping all and Disable it 
+        '''
+        import re
+        import copy
+        import time
+        numCtrls = main.params['CTRL']['numCtrl']
+        main.log.report("Enable Reactive forwarding and Verify ping all")
+        main.log.report("______________________________________________")        
+        main.case ("Enable Reactive forwarding and Verify ping all")
+        main.step("Enable Reactive forwarding")
+        installResult = main.TRUE
+        for i in range(1,int(numCtrls)+1):
+            onosFeature = 'onos-app-fwd'
+            ONOS_ip = main.params['CTRL']['ip'+str(i)]
+            ONOScli = 'ONOScli'+str(i)
+            main.log.info("Enabling Reactive mode on ONOS Node "+ONOS_ip)
+            exec "inResult=main."+ONOScli+".feature_install(onosFeature)"
+            installResult = inResult and installResult
+
+        time.sleep(5)
+
+        main.step("Verify Pingall")
+        ping_result = main.FALSE
+        time1 = time.time()
+        ping_result = main.Mininet1.pingall()
+        time2 = time.time()
+        timeDiff = round((time2-time1),2)
+        main.log.report("Time taken for Ping All: "+str(timeDiff)+" seconds")
+
+        if ping_result == main.TRUE:
+            main.log.report("Pingall Test in Reactive mode successful")
+        else:
+            main.log.report("Pingall Test in Reactive mode failed")
+
+        main.step("Disable Reactive forwarding")
+        uninstallResult = main.TRUE
+        for i in range(1,int(numCtrls)+1):
+            onosFeature = 'onos-app-fwd'
+            ONOS_ip = main.params['CTRL']['ip'+str(i)]
+            ONOScli = 'ONOScli'+str(i)
+            main.log.info("Disabling Reactive mode on ONOS Node "+ONOS_ip)
+            exec "unResult=main."+ONOScli+".feature_uninstall(onosFeature)"
+            uninstallResult = unResult and uninstallResult
+
+        #Waiting for reative flows to be cleared.
+        time.sleep(10)
+
+        case3Result = installResult and ping_result and uninstallResult
+        utilities.assert_equals(expect=main.TRUE, actual=case3Result,
+                onpass="Reactive Mode Pingall test PASS",
+                onfail="Reactive Mode Pingall test FAIL")
+
+    def CASE5(self,main) :
+        '''
+        Compare current ONOS topology with reference data
+        '''  
+        import re
+        devicesDPID_tmp = []
+        hostMACs_tmp = []
+        deviceLinks_tmp = []
+        deviceActiveLinksCount_tmp = []
+        devicePortsEnabledCount_tmp = []
+
+        main.log.report("Compare ONOS topology with reference data in Stores")
+        main.log.report("__________________________________________________")        
+        main.case ("Compare ONOS topology with reference data")
+	     
+        main.step("Compare current Device ports enabled with reference")
+        for i in range(1,26):
+            portResult = main.ONOScli1.getDevicePortsEnabledCount("of:00000000000000"+format(i, '02x'))
+            portTemp = re.split(r'\t+', portResult)
+            portCount = portTemp[1].replace("\r\r\n\x1b[32m","")
+            devicePortsEnabledCount_tmp.append(portCount)
+            time.sleep(2)
+        print ("Device Enabled ports EXPECTED: \n"+ str(devicePortsEnabledCount))
+        print ("Device Enabled ports ACTUAL: \n"+ str(devicePortsEnabledCount_tmp))
+        if (cmp(devicePortsEnabledCount,devicePortsEnabledCount_tmp)==0):
+            stepResult1 = main.TRUE
+        else:
+            stepResult1 = main.FALSE
+
+        main.step("Compare Device active links with reference")
+        for i in range(1,26):
+            linkResult = main.ONOScli1.getDeviceLinksActiveCount("of:00000000000000"+format(i, '02x'))
+            linkTemp = re.split(r'\t+', linkResult)
+            linkCount = linkTemp[1].replace("\r\r\n\x1b[32m","")
+            deviceActiveLinksCount_tmp.append(linkCount)
+            time.sleep(3)
+        print ("Device Active links EXPECTED: \n"+str(deviceActiveLinksCount))
+        print ("Device Active links ACTUAL: \n"+str(deviceActiveLinksCount_tmp))
+        if (cmp(deviceActiveLinksCount,deviceActiveLinksCount_tmp)==0):
+            stepResult2 = main.TRUE
+        else:
+            stepResult2 = main.FALSE
+
+        '''
+        place holder for comparing devices, hosts and paths if required. 
+        Links and ports data would be incorrect with out devices anyways.
+        '''
+
+        caseResult=(stepResult1 and stepResult2)
+        utilities.assert_equals(expect=main.TRUE, actual=case1Result,
+                onpass="Compare Topology test PASS",
+                onfail="Compare Topology test FAIL")
+        if caseResult == main.TRUE:
+            main.log.report("Compare Topology test Pass")
+
+    def CASE6(self):
+        '''
+        Install 300 host intents and verify ping all
+        '''
+        main.log.report("Add 300 host intents and verify pingall")
+        main.log.report("_______________________________________")
+        import itertools
+        main.case("Install 300 host intents")
+        main.step("Add host Intents")
+        intentResult=main.TRUE
+        hostCombos = list(itertools.combinations(hostMACs, 2))
+        for i in range(len(hostCombos)):
+            iResult = main.ONOScli1.add_host_intent(hostCombos[i][0],hostCombos[i][1])
+            intentResult=(intentResult and iResult)
+
+        main.step("Verify Ping across all hosts")
+        pingResult = main.FALSE
+        time1 = time.time()
+        pingResult = main.Mininet1.pingall()
+        time2 = time.time()
+        timeDiff = round((time2-time1),2)
+        main.log.report("Time taken for Ping All: "+str(timeDiff)+" seconds")
+        utilities.assert_equals(expect=main.TRUE, actual=pingResult,
+                onpass="PING ALL PASS",
+                onfail="PING ALL FAIL")
+
+        case4Result=(intentResult and pingResult)
+        utilities.assert_equals(expect=main.TRUE, actual=case4Result,
+                onpass="Install 300 Host Intents and Ping All test PASS",
+                onfail="Install 300 Host Intents and Ping All test FAIL")
+
+    def CASE7(self,main):
+        '''
+        Randomly bring some core links down and verify ping all
+        '''
+        import random
+        ONOS1_ip = main.params['CTRL']['ip1']
+        link1End1 = main.params['CORELINKS']['linkS3a']
+        link1End2 = main.params['CORELINKS']['linkS3b'].split(',')
+        link2End1 = main.params['CORELINKS']['linkS14a']
+        link2End2 = main.params['CORELINKS']['linkS14b'].split(',')
+        link3End1 = main.params['CORELINKS']['linkS18a']
+        link3End2 = main.params['CORELINKS']['linkS18b'].split(',')
+        switchLinksToToggle = main.params['CORELINKS']['toggleLinks']
+        link_sleep = int(main.params['timers']['LinkDiscovery'])
+
+        main.log.report("Randomly bring some core links down and verify ping all")
+        main.log.report("____________________________________________________")        
+        main.case("Randomly bring some core links down and verify ping all")
+        main.step("Verify number of Switch links to toggle on each Core Switch are between 1 - 5")
+        if (int(switchLinksToToggle) == 0 or int(switchLinksToToggle) > 5):
+            main.log.info("Please check you PARAMS file. Valid range for number of switch links to toggle is between 1 to 5")
+            main.cleanup()
+            main.exit()
+        else:
+            main.log.info("User provided Core switch links range to toggle is correct, proceeding to run the test")
+
+        main.step("Cut links on Core devices using user provided range")
+        randomLink1 = random.sample(link1End2,int(switchLinksToToggle))
+        randomLink2 = random.sample(link2End2,int(switchLinksToToggle))
+        randomLink3 = random.sample(link3End2,int(switchLinksToToggle))
+        for i in range(int(switchLinksToToggle)):
+            main.Mininet1.link(END1=link1End1,END2=randomLink1[i],OPTION="down")
+            main.Mininet1.link(END1=link2End1,END2=randomLink2[i],OPTION="down")
+            main.Mininet1.link(END1=link3End1,END2=randomLink3[i],OPTION="down")
+        time.sleep(link_sleep)
+
+        topology_output = main.ONOScli2.topology()
+        linkDown = main.ONOSbench.check_status(topology_output,numSwitches,str(int(numLinks)-int(switchLinksToToggle)*6))
+        utilities.assert_equals(expect=main.TRUE,actual=linkDown,
+                onpass="Link Down discovered properly",
+                onfail="Link down was not discovered in "+ str(link_sleep) + " seconds")
+
+        main.step("Verify Ping across all hosts")
+        pingResultLinkDown = main.FALSE
+        time1 = time.time()
+        pingResultLinkDown = main.Mininet1.pingall()
+        time2 = time.time()
+        timeDiff = round((time2-time1),2)
+        main.log.report("Time taken for Ping All: "+str(timeDiff)+" seconds")
+        utilities.assert_equals(expect=main.TRUE, actual=pingResultLinkDown,
+                onpass="PING ALL PASS",
+                onfail="PING ALL FAIL")
+
+        caseResult7 = linkDown and pingResultLinkDown
+        utilities.assert_equals(expect=main.TRUE, actual=caseResult7,
+                onpass="Random Link cut Test PASS",
+                onfail="Random Link cut Test FAIL")
+
+    def CASE8(self,main):
+        '''
+        Bring the core links up that are down and verify ping all
+        '''
+        import random
+        ONOS1_ip = main.params['CTRL']['ip1']
+        link1End1 = main.params['CORELINKS']['linkS3a']
+        link2End1 = main.params['CORELINKS']['linkS14a']
+        link3End1 = main.params['CORELINKS']['linkS18a']
+        link_sleep = int(main.params['timers']['LinkDiscovery'])
+        switchLinksToToggle = main.params['CORELINKS']['toggleLinks']
+
+        main.log.report("Bring the core links up that are down and verify ping all")
+        main.log.report("_____________________________________________________")        
+        main.case("Bring the core links up that are down and verify ping all")
+        main.step("Bring randomly cut links on Core devices up")
+        for i in range(int(switchLinksToToggle)): 
+            main.Mininet1.link(END1=link1End1,END2=randomLink1[i],OPTION="up")
+            main.Mininet1.link(END1=link2End1,END2=randomLink2[i],OPTION="up")
+            main.Mininet1.link(END1=link3End1,END2=randomLink3[i],OPTION="up")
+        time.sleep(link_sleep)
+
+        topology_output = main.ONOScli2.topology()
+        linkUp = main.ONOSbench.check_status(topology_output,numSwitches,str(numLinks))
+        utilities.assert_equals(expect=main.TRUE,actual=linkUp,
+                onpass="Link up discovered properly",
+                onfail="Link up was not discovered in "+ str(link_sleep) + " seconds")
+
+        main.step("Verify Ping across all hosts")
+        pingResultLinkUp = main.FALSE
+        time1 = time.time()
+        pingResultLinkUp = main.Mininet1.pingall()
+        time2 = time.time()
+        timeDiff = round((time2-time1),2)
+        main.log.report("Time taken for Ping All: "+str(timeDiff)+" seconds")
+        utilities.assert_equals(expect=main.TRUE, actual=pingResultLinkUp,
+                onpass="PING ALL PASS",
+                onfail="PING ALL FAIL")
+
+        caseResult8 = linkUp and pingResultLinkUp
+        utilities.assert_equals(expect=main.TRUE, actual=caseResult8,
+                onpass="Link Up Test PASS",
+                onfail="Link Up Test FAIL")    
+
+    def CASE9(self):
+        '''
+        Install 114 point intents and verify Ping all works
+        '''
+        import copy
+        main.log.report("Install 114 point intents and verify Ping all")
+        main.log.report("___________________________________________")        
+        main.case("Install 114 point intents and Ping all")
+        deviceLinks_copy = copy.copy(deviceLinks)
+        main.step("Install 114 point intents")
+        for i in range(len(deviceLinks_copy)):
+            pointLink = str(deviceLinks_copy[i]).replace("src=","").replace("dst=","").split(',')
+            point1 = pointLink[0].split('/')
+            point2 = pointLink[1].split('/')
+            installResult = main.ONOScli1.add_point_intent(point1[0],point2[0],int(point1[1]),int(point2[1]))
+            if installResult == main.TRUE:
+                print "Installed Point intent between :",point1[0], int(point1[1]), point2[0], int(point2[1])
+
+        main.step("Obtain the intent id's")
+        intentsList = main.ONOScli1.getAllIntentIds()
+        ansi_escape = re.compile(r'\x1b[^m]*m')
+        intentsList = ansi_escape.sub('', intentsList)
+        intentsList = intentsList.replace(" onos:intents | grep id=","").replace("id=","").replace("\r\r","")
+        intentsList=intentsList.splitlines()
+        intentsList = intentsList[1:]
+        intentIdList = []
+        for i in range(len(intentsList)):
+            intentsTemp = intentsList[i].split(',')
+            intentIdList.append(intentsTemp[0])
+        print "Intent IDs: ", intentIdList
+        print "Total Intents installed: ", len(intentIdList)
+
+        main.step("Verify Ping across all hosts")
+        pingResult = main.FALSE
+        time1 = time.time()
+        pingResult = main.Mininet1.pingall()
+        time2 = time.time()
+        timeDiff = round((time2-time1),2)
+        main.log.report("Time taken for Ping All: "+str(timeDiff)+" seconds")
+        utilities.assert_equals(expect=main.TRUE, actual=pingResult,
+                onpass="PING ALL PASS",
+                onfail="PING ALL FAIL")
+
+        case8_result = installResult and pingResult
+        utilities.assert_equals(expect=main.TRUE, actual=case8_result,
+                onpass="Ping all test after Point intents addition successful",
+                onfail="Ping all test after Point intents addition failed")
+
+    def CASE10(self):
+        '''
+         Remove all Intents
+        ''' 
+        main.log.report("Remove all intents that were installed previously")
+        main.log.report("______________________________________________")        
+        main.log.info("Remove all intents")
+        main.case("Removing intents")
+        main.step("Obtain the intent id's first")
+        intentsList = main.ONOScli1.getAllIntentIds()
+        ansi_escape = re.compile(r'\x1b[^m]*m')
+        intentsList = ansi_escape.sub('', intentsList)
+        intentsList = intentsList.replace(" onos:intents | grep id=","").replace("id=","").replace("\r\r","")
+        intentsList=intentsList.splitlines()
+        intentsList = intentsList[1:]
+        intentIdList = []
+        step1Result = main.TRUE
+        if (len(intentsList) > 1):
+            for i in range(len(intentsList)):
+                intentsTemp = intentsList[i].split(',')
+                intentIdList.append(intentsTemp[0])
+            print "Intent IDs: ", intentIdList
+            for id in range(len(intentIdList)):
+                print "Removing intent id (round 1) :", intentIdList[id]
+                main.ONOScli1.remove_intent(intent_id = intentIdList[id])
+                time.sleep(1)
+
+            main.log.info("Verify all intents are removed and if any leftovers try remove one more time")
+            intentsList1 = main.ONOScli1.getAllIntentIds()
+            ansi_escape = re.compile(r'\x1b[^m]*m')
+            intentsList1 = ansi_escape.sub('', intentsList1)
+            intentsList1 = intentsList1.replace(" onos:intents | grep id=","").replace(" state=","").replace("\r\r","")
+            intentsList1=intentsList1.splitlines()
+            intentsList1 = intentsList1[1:]
+            print "Round 2 (leftover) intents to remove: ", intentsList1
+            intentIdList1 = []
+            if (len(intentsList1) > 1):
+                for i in range(len(intentsList1)):
+                    intentsTemp1 = intentsList[i].split(',')
+                    intentIdList1.append(intentsTemp1[0])
+                print "Leftover Intent IDs: ", intentIdList1
+                for id in range(len(intentIdList1)):
+                    print "Removing intent id (round 2):", intentIdList1[id]
+                    main.ONOScli1.remove_intent(intent_id = intentIdList1[id])
+                    time.sleep(2)
+            else:
+                print "There are no more intents that need to be removed"
+                step1Result = main.TRUE
+        else:
+            print "No Intent IDs found in Intents list: ", intentsList
+            step1Result = main.FALSE
+
+        caseResult7 = step1Result
+        utilities.assert_equals(expect=main.TRUE, actual=caseResult7,
+                onpass="Intent removal test successful",
+                onfail="Intent removal test failed")
\ No newline at end of file
diff --git a/TestON/tests/OnosCHO/OnosCHO.topo b/TestON/tests/OnosCHO/OnosCHO.topo
new file mode 100644
index 0000000..2a79611
--- /dev/null
+++ b/TestON/tests/OnosCHO/OnosCHO.topo
@@ -0,0 +1,133 @@
+<TOPOLOGY>
+    <COMPONENT>
+
+        <ONOSbench>
+            <host>10.128.40.40</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosDriver</type>
+            <connect_order>1</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOSbench>
+
+        <ONOScli1>
+            <host>10.128.40.40</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosCliDriver</type>
+            <connect_order>2</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOScli1>
+
+	 <ONOScli2>
+            <host>10.128.40.40</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosCliDriver</type>
+            <connect_order>3</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOScli2>
+
+	 <ONOScli3>
+            <host>10.128.40.40</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosCliDriver</type>
+            <connect_order>4</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOScli3>
+
+        <ONOScli4>
+            <host>10.128.40.40</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosCliDriver</type>
+            <connect_order>5</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOScli4>
+
+	 <ONOScli5>
+            <host>10.128.40.40</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosCliDriver</type>
+            <connect_order>6</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOScli5>
+	
+        <ONOS1>
+            <host>10.128.40.40</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosCliDriver</type>
+            <connect_order>7</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOS1>
+
+	<ONOS2>
+            <host>10.128.40.40</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosCliDriver</type>
+            <connect_order>8</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOS2>
+	
+	<ONOS3>
+            <host>10.128.40.40</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosCliDriver</type>
+            <connect_order>9</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOS3>
+
+        <ONOS4>
+            <host>10.128.40.40</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosCliDriver</type>
+            <connect_order>10</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOS4>
+
+	<ONOS5>
+            <host>10.128.40.40</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosCliDriver</type>
+            <connect_order>11</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOS5>
+	
+        <Mininet1>
+            <host>10.128.40.40</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>MininetCliDriver</type>
+            <connect_order>12</connect_order>
+            <COMPONENTS>
+                #Specify the Option for mininet
+                <arg1> --custom ~/mininet/custom/att-mpls-topo.py </arg1>
+                <arg2> --topo att </arg2>
+                <arg3> --link tc --switch ovs,protocols=OpenFlow13 </arg3>
+                <controller> remote </controller>
+            </COMPONENTS>
+        </Mininet1>
+
+        <Mininet2>
+            <host>10.128.40.40</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>RemoteMininetDriver</type>
+            <connect_order>13</connect_order>
+            <COMPONENTS>
+                #Specify the Option for mininet
+                <arg1> --custom ~/mininet/custom/att-mpls-topo.py </arg1>
+                <arg2> --topo att </arg2>
+                <arg3> --link tc --switch ovs,protocols=OpenFlow13 </arg3>
+                <controller> remote </controller>
+            </COMPONENTS>
+        </Mininet2>
+    </COMPONENT>
+</TOPOLOGY>
diff --git a/TestON/tests/JonTest/__init__.py b/TestON/tests/OnosCHO/__init__.py
similarity index 100%
rename from TestON/tests/JonTest/__init__.py
rename to TestON/tests/OnosCHO/__init__.py
diff --git a/TestON/tests/PingallExample/PingallExample.params b/TestON/tests/PingallExample/PingallExample.params
new file mode 100644
index 0000000..aecaab6
--- /dev/null
+++ b/TestON/tests/PingallExample/PingallExample.params
@@ -0,0 +1,12 @@
+<PARAMS>
+    <testcases>1,2,3</testcases>
+    <ENV>
+        <cellName>HA</cellName>
+    </ENV>
+    <Git>True</Git>
+
+    <CTRL>
+        <ip1>10.128.30.11</ip1>
+        <port1>6633</port1>
+    </CTRL>
+</PARAMS>
diff --git a/TestON/tests/PingallExample/PingallExample.py b/TestON/tests/PingallExample/PingallExample.py
new file mode 100644
index 0000000..faf374f
--- /dev/null
+++ b/TestON/tests/PingallExample/PingallExample.py
@@ -0,0 +1,162 @@
+"""
+Description: This test is an example of a simple single node ONOS test
+
+List of test cases:
+CASE1: Compile ONOS and push it to the test machine
+CASE2: Assign mastership to controller
+CASE3: Pingall
+"""
+class PingallExample:
+
+    def __init__( self ) :
+        self.default = ''
+
+    def CASE1( self, main ) :
+        """
+           CASE1 is to compile ONOS and push it to the test machines
+
+           Startup sequence:
+           git pull
+           mvn clean install
+           onos-package
+           cell <name>
+           onos-verify-cell
+           onos-install -f
+           onos-wait-for-start
+        """
+        desc = "ONOS Single node cluster restart HA test - initialization"
+        main.log.report( desc )
+        main.case( "Setting up test environment" )
+
+        # load some vairables from the params file
+        PULL_CODE = False
+        if main.params[ 'Git' ] == 'True':
+            PULL_CODE = True
+        cell_name = main.params[ 'ENV' ][ 'cellName' ]
+
+        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+        main.step( "Applying cell variable to environment" )
+        cell_result = main.ONOSbench.set_cell( cell_name )
+        verify_result = main.ONOSbench.verify_cell()
+
+        main.log.report( "Uninstalling ONOS" )
+        main.ONOSbench.onos_uninstall( ONOS1_ip )
+
+        clean_install_result = main.TRUE
+        git_pull_result = main.TRUE
+
+        main.step( "Compiling the latest version of ONOS" )
+        if PULL_CODE:
+            main.step( "Git checkout and pull master" )
+            main.ONOSbench.git_checkout( "master" )
+            git_pull_result = main.ONOSbench.git_pull()
+
+            main.step( "Using mvn clean & install" )
+            clean_install_result = main.TRUE
+            if git_pull_result == main.TRUE:
+                clean_install_result = main.ONOSbench.clean_install()
+            else:
+                main.log.warn( "Did not pull new code so skipping mvn " +
+                               "clean install" )
+        main.ONOSbench.get_version( report=True )
+
+        cell_result = main.ONOSbench.set_cell( cell_name )
+        verify_result = main.ONOSbench.verify_cell()
+        main.step( "Creating ONOS package" )
+        package_result = main.ONOSbench.onos_package()
+
+        main.step( "Installing ONOS package" )
+        onos1_install_result = main.ONOSbench.onos_install( options="-f",
+                                                            node=ONOS1_ip )
+
+        main.step( "Checking if ONOS is up yet" )
+        for i in range( 2 ):
+            onos1_isup = main.ONOSbench.isup( ONOS1_ip )
+            if onos1_isup:
+                break
+        if not onos1_isup:
+            main.log.report( "ONOS1 didn't start!" )
+
+        # TODO: if it becomes an issue, we can retry this step  a few times
+
+        cli_result = main.ONOScli1.start_onos_cli( ONOS1_ip )
+
+        case1_result = ( clean_install_result and package_result and
+                         cell_result and verify_result and
+                         onos1_install_result and
+                         onos1_isup and cli_result )
+
+        utilities.assert_equals( expect=main.TRUE, actual=case1_result,
+                                 onpass="Test startup successful",
+                                 onfail="Test startup NOT successful" )
+
+        if case1_result == main.FALSE:
+            main.cleanup()
+            main.exit()
+
+    def CASE2( self, main ) :
+        """
+           Assign mastership to controller
+        """
+        import re
+
+        main.log.report( "Assigning switches to controller" )
+        main.case( "Assigning Controller" )
+        main.step( "Assign switches to controller" )
+
+        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+        ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
+
+        for i in range( 1, 14 ):
+            main.Mininet1.assign_sw_controller(
+                sw=str( i ),
+                ip1=ONOS1_ip,
+                port1=ONOS1_port )
+
+        mastership_check = main.TRUE
+        for i in range( 1, 14 ):
+            response = main.Mininet1.get_sw_controller( "s" + str( i ) )
+            try:
+                main.log.info( str( response ) )
+            except:
+                main.log.info( repr( response ) )
+            if re.search( "tcp:" + ONOS1_ip, response ):
+                mastership_check = mastership_check and main.TRUE
+            else:
+                mastership_check = main.FALSE
+        if mastership_check == main.TRUE:
+            main.log.report( "Switch mastership assigned correctly" )
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=mastership_check,
+            onpass="Switch mastership assigned correctly",
+            onfail="Switches not assigned correctly to controllers" )
+
+    def CASE3( self, main ) :
+        """
+           Assign intents
+        """
+        import time
+
+        main.log.report( "Run Pingall" )
+        main.case( "Run Pingall" )
+
+        # install onos-app-fwd
+        main.log.info( "Install reactive forwarding app" )
+        main.ONOScli1.feature_install( "onos-app-fwd" )
+
+        # REACTIVE FWD test
+        ping_result = main.FALSE
+        time1 = time.time()
+        ping_result = main.Mininet1.pingall()
+        time2 = time.time()
+        main.log.info( "Time for pingall: %2f seconds" % ( time2 - time1 ) )
+
+        # uninstall onos-app-fwd
+        main.log.info( "Uninstall reactive forwarding app" )
+        main.ONOScli1.feature_uninstall( "onos-app-fwd" )
+
+        utilities.assert_equals( expect=main.TRUE, actual=ping_result,
+                                 onpass="All hosts are reachable",
+                                 onfail="Some pings failed" )
diff --git a/TestON/tests/JonTest/JonTest.topo b/TestON/tests/PingallExample/PingallExample.topo
old mode 100755
new mode 100644
similarity index 60%
rename from TestON/tests/JonTest/JonTest.topo
rename to TestON/tests/PingallExample/PingallExample.topo
index bf8cb18..1712756
--- a/TestON/tests/JonTest/JonTest.topo
+++ b/TestON/tests/PingallExample/PingallExample.topo
@@ -4,7 +4,7 @@
         <ONOSbench>
             <host>10.128.30.10</host>
             <user>admin</user>
-            <password>onos_test</password>
+            <password></password>
             <type>OnosDriver</type>
             <connect_order>1</connect_order>
             <COMPONENTS> </COMPONENTS>
@@ -13,21 +13,12 @@
         <ONOScli1>
             <host>10.128.30.10</host>
             <user>admin</user>
-            <password>onos_test</password>
+            <password></password>
             <type>OnosCliDriver</type>
             <connect_order>2</connect_order>
             <COMPONENTS> </COMPONENTS>
         </ONOScli1>
 
-        <ONOScli2>
-            <host>10.128.30.10</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>OnosCliDriver</type>
-            <connect_order>2</connect_order>
-            <COMPONENTS> </COMPONENTS>
-        </ONOScli2>
-
         <ONOS1>
             <host>10.128.30.11</host>
             <user>sdn</user>
@@ -37,24 +28,15 @@
             <COMPONENTS> </COMPONENTS>
         </ONOS1>
 
-        <ONOS2>
-            <host>10.128.30.12</host>
-            <user>sdn</user>
-            <password>rocks</password>
-            <type>OnosDriver</type>
-            <connect_order>3</connect_order>
-            <COMPONENTS> </COMPONENTS>
-        </ONOS2>
-
         <Mininet1>
-            <host>10.128.11.11</host>
+            <host>10.128.30.9</host>
             <user>admin</user>
-            <password>onos_test</password>
+            <password></password>
             <type>MininetCliDriver</type>
             <connect_order>4</connect_order>
             <COMPONENTS>
                 #Specify the Option for mininet
-                <arg1> --topo tree,2,3</arg1>
+                <arg1> --topo=tree,3,3 </arg1>
                 <arg2> </arg2>
                 <arg3> </arg3>
                 <controller> remote </controller>
diff --git a/TestON/tests/PoxTest/__init__.py b/TestON/tests/PingallExample/__init__.py
similarity index 100%
rename from TestON/tests/PoxTest/__init__.py
rename to TestON/tests/PingallExample/__init__.py
diff --git a/TestON/tests/PoxTest/.svn/entries b/TestON/tests/PoxTest/.svn/entries
deleted file mode 100644
index b51d7ac..0000000
--- a/TestON/tests/PoxTest/.svn/entries
+++ /dev/null
@@ -1,171 +0,0 @@
-9
-
-dir
-65
-svn://192.168.150.61/OpenFlow/tests/PoxTest
-svn://192.168.150.61/OpenFlow
-
-
-
-2012-12-05T18:46:42.405397Z
-65
-paxterra
-
-
-svn:special svn:externals svn:needs-lock
-
-
-
-
-
-
-
-
-
-
-
-8b1d8634-a80c-44fc-ab7b-cc53e6f68013
-
-
-
-
-
-
-0
-
-PoxTest.params
-file
-
-
-
-
-2012-12-05T16:08:24.000000Z
-e79bef68fc6f00acd8bf2028a7e2cab0
-2012-12-05T18:46:42.405397Z
-65
-paxterra
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-326
-
-PoxTest.py
-file
-
-
-
-
-2012-12-05T16:08:24.000000Z
-4a2b2aaeb2a2eeed4b70f1adebca7231
-2012-12-05T18:46:42.405397Z
-65
-paxterra
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-637
-
-PoxTest.topo
-file
-
-
-
-
-2012-12-05T16:08:24.000000Z
-827eb99b5a13c33d371ffc6aca740464
-2012-12-05T18:46:42.405397Z
-65
-paxterra
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-805
-
-__init__.py
-file
-
-
-
-
-2012-12-05T16:08:24.000000Z
-d41d8cd98f00b204e9800998ecf8427e
-2012-12-05T18:46:42.405397Z
-65
-paxterra
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-0
-
diff --git a/TestON/tests/PoxTest/.svn/format b/TestON/tests/PoxTest/.svn/format
deleted file mode 100644
index ec63514..0000000
--- a/TestON/tests/PoxTest/.svn/format
+++ /dev/null
@@ -1 +0,0 @@
-9
diff --git a/TestON/tests/PoxTest/.svn/text-base/PoxTest.params.svn-base b/TestON/tests/PoxTest/.svn/text-base/PoxTest.params.svn-base
deleted file mode 100644
index bbadcaa..0000000
--- a/TestON/tests/PoxTest/.svn/text-base/PoxTest.params.svn-base
+++ /dev/null
@@ -1,12 +0,0 @@
-[PARAMS]
-    'testcases' = '[1]'
-    'mail' = 'anilkumar.s@paxterrasolutions.com,paxweb@paxterrasolutions.com'
-    #'log_dir' = '/home/user/Desktop/openflow_logs/'
-    [[CASE1]]
-        'destination' = 'h2'
-        'src' = 'h2'
-        'target'= 'h3'
-        'controller' = 'c1'
-        [[[STEP1]]]
-            'host' = 'h2'
-
diff --git a/TestON/tests/PoxTest/.svn/text-base/PoxTest.py.svn-base b/TestON/tests/PoxTest/.svn/text-base/PoxTest.py.svn-base
deleted file mode 100644
index 49e63af..0000000
--- a/TestON/tests/PoxTest/.svn/text-base/PoxTest.py.svn-base
+++ /dev/null
@@ -1,15 +0,0 @@
-class PoxTest:
-    '''
-    Testing Basic Pox Functionalities
-    '''
-    def __init__(self):
-        self.default = ""
-
-    def CASE1(self,main):
-        main.case("Checking the control flow of POX")
-        main.step("Checking the host reachability using pingHost ")
-        
-        result = main.Mininet1.pingHost(src=main.params['CASE1']['src'],
-                                        target=main.params['CASE1']['target'],
-                                        controller=main.params['CASE1']['controller'])
-        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Ping executed successfully",onfail="Ping Failed")
diff --git a/TestON/tests/PoxTest/.svn/text-base/PoxTest.topo.svn-base b/TestON/tests/PoxTest/.svn/text-base/PoxTest.topo.svn-base
deleted file mode 100644
index b4560cb..0000000
--- a/TestON/tests/PoxTest/.svn/text-base/PoxTest.topo.svn-base
+++ /dev/null
@@ -1,25 +0,0 @@
-[TOPOLOGY]
-
-    [[COMPONENT]]
-        [[["Mininet1"]]]
-            'host' = '192.168.56.101'
-            'user' = 'openflow'
-            'password' = 'openflow'
-            'type' = "Mininet"
-            [[[["COMPONENTS"]]]]
-                # Specify the Option for mininet
-                'topo' = 'single'
-                'topocount' = '3'
-                'switch' = 'ovsk'
-                'controller' = 'remote'
-        [[["POX2"]]]
-            'host' = '192.168.56.101'
-            'user' = 'openflow'
-            'password' = 'openflow'
-            'type' = 'POX'
-            'test_target' = '1'
-            'no-cli' = '1' #or '0' if want to run in cli mode
-            [[[["COMPONENTS"]]]]
-                'pox_lib_location' = "/home/openflow/pox/"
-                [[[[["samples.of_tutorial"]]]]]
-
diff --git a/TestON/tests/PoxTest/.svn/text-base/__init__.py.svn-base b/TestON/tests/PoxTest/.svn/text-base/__init__.py.svn-base
deleted file mode 100644
index e69de29..0000000
--- a/TestON/tests/PoxTest/.svn/text-base/__init__.py.svn-base
+++ /dev/null
diff --git a/TestON/tests/PoxTest/PoxTest.ospk b/TestON/tests/PoxTest/PoxTest.ospk
deleted file mode 100644
index cadc43e..0000000
--- a/TestON/tests/PoxTest/PoxTest.ospk
+++ /dev/null
@@ -1,7 +0,0 @@
-CASE 1
-    NAME "Checking the control flow of POX"
-    STEP "Checking the host reachability using pingHost"
-    ON Mininet1 DO pingHost USING src AS CASE["src"], target AS CASE["target"], controller AS CASE["controller"] AND STORE LAST_RESULT IN result
-    ASSERT result EQUALS main.TRUE ONPASS "Ping executed successfully" ONFAIL "Ping failed"
-
-
diff --git a/TestON/tests/PoxTest/PoxTest.params b/TestON/tests/PoxTest/PoxTest.params
deleted file mode 100644
index dfff20e..0000000
--- a/TestON/tests/PoxTest/PoxTest.params
+++ /dev/null
@@ -1,13 +0,0 @@
-<PARAMS>
-    <testcases> [1]</testcases>
-    <mail> anil4haart@gmail.com,paxweb@paxterrasolutions.com</mail>
-    <CASE1>
-        <destination> h2</destination>
-        <src>h2</src>
-        <target> h3 </target>
-        <controller> c1 </controller>
-        <STEP1>
-            <host> h2</host>
-        </STEP1> 
-    </CASE1>
-</PARAMS>
diff --git a/TestON/tests/PoxTest/PoxTest.py b/TestON/tests/PoxTest/PoxTest.py
deleted file mode 100644
index f9e4722..0000000
--- a/TestON/tests/PoxTest/PoxTest.py
+++ /dev/null
@@ -1,29 +0,0 @@
-'''
-	
- *   TestON is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 2 of the License, or
- *   (at your option) any later version.
-
- *   TestON is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
-
-
-'''
-
-class PoxTest :
-
-    def __init__(self) :
-        self.default = ''
-
-    def CASE1(self,main) :
-
-        main.case("Checking the control flow of POX")
-        main.step("Checking the host reachability using pingHost")
-        main.Mininet1.pingHost(src=main.params['CASE1']['src'], target=main.params['CASE1']['target'], controller=main.params['CASE1']['controller'])
-        result = main.last_result
-        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Ping executed successfully",onfail="Ping failed")
-    
-    
diff --git a/TestON/tests/PoxTest/PoxTest.topo b/TestON/tests/PoxTest/PoxTest.topo
deleted file mode 100644
index e42a300..0000000
--- a/TestON/tests/PoxTest/PoxTest.topo
+++ /dev/null
@@ -1,31 +0,0 @@
-<TOPOLOGY>
-
-    <COMPONENT>
-        <Mininet1>
-            <host>192.168.56.101</host>
-            <user> openflow</user>
-            <password> openflow</password>
-            <type>MininetCliDriver</type>
-            <COMPONENTS>
-                # Specify the Option for mininet
-                <topo> single</topo>
-                <topocount>3</topocount>
-                <switch> ovsk </switch>
-                <controller> remote </controller>
-             </COMPONENTS>   
-        </Mininet1>        
-        <POX2>
-            <host> 192.168.56.101 </host>
-            <user>  openflow </user>
-            <password> openflow </password>
-            <type> PoxCliDriver </type>
-            <test_target> 1 </test_target>
-            <COMPONENTS>
-                <pox_lib_location> /home/openflow/pox/  </pox_lib_location>
-                <samples.of_tutorial></samples.of_tutorial>
-            </COMPONENTS>
-        </POX2>
-
-        
-    </COMPONENT>
-</TOPOLOGY>
\ No newline at end of file
diff --git a/TestON/tests/VyattaTest/VyattaTest.params b/TestON/tests/VyattaTest/VyattaTest.params
deleted file mode 100644
index 92a5b20..0000000
--- a/TestON/tests/VyattaTest/VyattaTest.params
+++ /dev/null
@@ -1,4 +0,0 @@
-<PARAMS>
-    <testcases> [1]</testcases>
-    <mail> anil4haart@gmail.com,paxweb@paxterrasolutions.com</mail>
-</PARAMS>
\ No newline at end of file
diff --git a/TestON/tests/VyattaTest/VyattaTest.py b/TestON/tests/VyattaTest/VyattaTest.py
deleted file mode 100644
index 7d4017b..0000000
--- a/TestON/tests/VyattaTest/VyattaTest.py
+++ /dev/null
@@ -1,95 +0,0 @@
-'''
-	
- *   TestON is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 2 of the License, or
- *   (at your option) any later version.
-
- *   TestON is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
-
-
-'''
-
-class VyattaTest :
-
-    def __init__(self) :
-        self.default = ''
-
-    def CASE1(self,main) :
-
-        main.case("VyattaTest Sample Test")
-        main.step("VyattaTest Sample Test")
-        config_result = main.Vyatta.configure()
-        main.log.info(config_result)
-        
-        command_details = main.Vyatta.get_details("show")
-        main.log.info("show \n command_details\n\t"+ str(command_details))
-        
-        command_details = main.Vyatta.get_details("show interfaces")
-        main.log.info("show interfaces \n command_details\n\t"+ str(command_details))
-                
-        command_details = main.Vyatta.get_details("show interfaces ethernet")
-        main.log.info("show interfaces ethernet \n command_details\n\t"+ str(command_details))
-                
-        command_details = main.Vyatta.get_details("show interfaces ethernet eth1")
-        main.log.info("show interfaces ethernet eth1 \n command_details\n\t"+ str(command_details))
-        
-        command_details = main.Vyatta.get_details("show interfaces ethernet eth1 address")
-        main.log.info("show interfaces ethernet eth1 address \n command_details\n\t"+ str(command_details))
-        
-        
-        '''
-        main.Vyatta.handle.expect("\$")
-        
-        resultCommand = main.Vyatta.execute(cmd="configure",prompt='\#',timeout=10)
-        
-        resultCommand = main.Vyatta.execute(cmd="show interfaces ?",prompt='\#',timeout=10)
-        
-        print "Possible Options \t\t"
-        print main.last_response
-        print " ->"*10+"\n"*4
-        import re
-        match = re.findall("\n\s*.\s+(\w+)", main.last_response, 0)
-        print match
-        
-        resultCommand = main.Vyatta.execute(cmd="XYZ",prompt='\#',timeout=10)
-        
-        print "Command result Upto here \t\t"
-        print main.last_response
-        print " ->"*10+"\n"*4
-        import re
-        match = re.findall("\n\s*.\s+(\w+)", main.last_response, 0)
-        print match
-        
-        
-        resultCommand = main.Vyatta.execute(cmd="XYZ",prompt='\#',timeout=10)
-        
-        print "Command result Upto here \t\t"
-        print main.last_response
-        print " ->"*10+"\n"*4
-        import re
-        match = re.findall("\n\s*.\s+(\w+)", main.last_response, 0)
-        print match
-        
-        
-        resultCommand = main.Vyatta.execute(cmd="show interfaces ethernet ?",prompt='\#',timeout=10)
-        
-        print "Possible Options \t\t"
-        print main.last_response
-        print " ->"*10+"\n"*4
-        import re
-        match = re.findall("\n\s*.\s+(\w+)", main.last_response, 0)
-        print match
-        
-        resultCommand = main.Vyatta.execute(cmd="XYZ",prompt='\#',timeout=10)
-        
-        print "Command result Upto here \t\t"
-        print main.last_response
-        print " ->"*10+"\n"*4
-        import re
-        match = re.findall("\n\s*.\s+(\w+)", main.last_response, 0)
-        print match
-        '''
diff --git a/TestON/tests/VyattaTest/VyattaTest.topo b/TestON/tests/VyattaTest/VyattaTest.topo
deleted file mode 100644
index 3b13543..0000000
--- a/TestON/tests/VyattaTest/VyattaTest.topo
+++ /dev/null
@@ -1,14 +0,0 @@
-<TOPOLOGY>
-
-    <COMPONENT>
-        <Vyatta>
-            <host>192.168.56.81</host>
-            <user> vyatta </user>
-            
-            <password>vyatta</password>
-            <type>RemoteSysDriver</type>
-            <COMPONENTS>
-            </COMPONENTS>   
-        </Vyatta>        
-    </COMPONENT>
-</TOPOLOGY>
diff --git a/TestON/tests/VyattaTest/__init__.py b/TestON/tests/VyattaTest/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/TestON/tests/VyattaTest/__init__.py
+++ /dev/null