diff --git a/.gitignore b/.gitignore
index 6cccacc..ae5f64f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 *.swp
+*.swo
 TestON/logs/*
 *.pyc
diff --git a/TestON/dependencies/Jenkins_getresult_HA.py b/TestON/dependencies/Jenkins_getresult_HA.py
new file mode 100755
index 0000000..f3ea459
--- /dev/null
+++ b/TestON/dependencies/Jenkins_getresult_HA.py
@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+
+import sys
+import os
+import re
+import datetime
+import time
+import argparse
+import shutil
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-n", "--name", help="Comma Separated string of test names. Ex: --name='test1, test2, test3'")
+parser.add_argument("-w", "--workspace", help="The name of the Jenkin's job/workspace where csv files will be saved'")
+args = parser.parse_args()
+
+#Pass in test names as a comma separated string argument. 
+#Example: ./Jenkins_getresult.py "Test1,Test2,Test3,Test4"
+name_list = args.name.split(",")
+result_list = map(lambda x: x.strip(), name_list)
+job = args.workspace
+if job is None:
+    job = ""
+print job
+
+#NOTE: testnames list should be in order in which it is run
+testnames = result_list
+output = ''
+header = ''
+graphs = ''
+testdate = datetime.datetime.now()
+#workspace = "/var/lib/jenkins/workspace/ONOS-HA"
+workspace = "/var/lib/jenkins/workspace/"
+workspace = workspace + job
+
+header +="<p>**************************************</p>"
+header +=testdate.strftime('Jenkins test result for %H:%M on %b %d, %Y. %Z')
+
+
+#NOTE: CASE SPECIFIC THINGS
+
+#THIS LINE IS LOUSY FIXME
+if any("HA" in s for s in testnames):
+    ##Graphs
+    graphs += '<ac:structured-macro ac:name="html">\n'
+    graphs += '<ac:plain-text-body><![CDATA[\n'
+    graphs += '<iframe src="https://onos-jenkins.onlab.us/job/'+job+'/plot/getPlot?index=2&width=500&height=300" noborder="0" width="500" height="300" scrolling="yes" seamless="seamless"></iframe>\n'
+    graphs += '<iframe src="https://onos-jenkins.onlab.us/job/'+job+'/plot/getPlot?index=1&width=500&height=300" noborder="0" width="500" height="300" scrolling="yes" seamless="seamless"></iframe>\n'
+    graphs += '<iframe src="https://onos-jenkins.onlab.us/job/'+job+'/plot/getPlot?index=0&width=500&height=300" noborder="0" width="500" height="300" scrolling="yes" seamless="seamless"></iframe>\n'
+    graphs += '<iframe src="https://onos-jenkins.onlab.us/job/'+job+'/plot/getPlot?index=3&width=500&height=300" noborder="0" width="500" height="300" scrolling="yes" seamless="seamless"></iframe>\n'
+    graphs += ']]></ac:plain-text-body>\n'
+    graphs += '</ac:structured-macro>\n'
+    header +="<p> <a href='https://wiki.onosproject.org/display/OST/Test+Plan+-+HA'>Test Plan for HA Test Cases</a></p>"
+
+
+# ***
+
+
+#TestON reporting
+for test in testnames:
+    passes = 0
+    fails = 0
+    name = os.popen("ls /home/admin/ONLabTest/TestON/logs/ -rt | grep %s_ | tail -1" % test).read().split()[0]
+    path = "/home/admin/ONLabTest/TestON/logs/" + name + "/"
+    try:
+        #IF exists, move the csv file to the workspace
+        shutil.copy(path + test + ".csv", workspace)
+    except IOError:
+        #File probably doesn't exist
+        pass
+
+    output +="<p></p>"
+    #output +="   Date: %s, %s %s" % (name.split("_")[2], name.split("_")[1], name.split("_")[3]) + "<p>*******************<p>"
+    #Open the latest log folder 
+    output += "<h2>Test "+str(test)+"</h2><p>************************************</p>"
+
+    f = open(path + name + ".rpt")
+
+    #Parse through each line of logs and look for specific strings to output to wiki.
+    #NOTE: with current implementation, you must specify which output to output to wiki by using
+    #main.log.report("") since it is looking for the [REPORT] tag in the logs
+    for line in f:
+        if re.search("Result summary for Testcase", line):
+            output += "<h3>"+str(line)+"</h3>"
+            #output += "<br>"
+        if re.search("\[REPORT\]", line): 
+            line_split = line.split("] ")
+            #line string is split by bracket, and first two items (log tags) in list are omitted from output
+            #join is used to convert list to string
+            line_str = ''.join(line_split[2:])
+            output += "<p>"
+            output += line_str
+            output += "</p>"
+        if re.search("Result:", line):
+            output += "<p>"
+            output += line
+            output += "</p>"
+            if re.search("Pass", line):
+                passes = passes + 1
+            elif re.search("Fail", line):
+                fails = fails + 1
+    f.close()
+    #https://wiki.onosproject.org/display/OST/Test+Results+-+HA#Test+Results+-+HA
+    #Example anchor on new wiki:        #TestResults-HA-TestHATestSanity
+    page_name = "TestResults-HA-Test"
+
+    header += "<li><a href=\'#" + str(page_name) + str(test) + "\'> " + str(test) + " - Results: " + str(passes) + " Passed, " + str(fails) + " Failed</a></li>"
+
+    #*********************
+    #include any other phrase specific to case you would like to include in wiki here
+    if test == "IntentPerf":
+        output += "URL to Historical Performance results data: <a href='http://10.128.5.54perf.html'>Perf Graph</a>"
+    #*********************
+
+#header_file = open("/tmp/header_ha.txt",'w')
+#header_file.write(header)
+output = header + graphs + output
+print output
diff --git a/TestON/drivers/common/cli/emulator/mininetclidriver.py b/TestON/drivers/common/cli/emulator/mininetclidriver.py
index 95e0cb9..a45ed20 100644
--- a/TestON/drivers/common/cli/emulator/mininetclidriver.py
+++ b/TestON/drivers/common/cli/emulator/mininetclidriver.py
@@ -1492,9 +1492,9 @@
         else:
             linkResults = main.FALSE
             main.log.report(
-                "Mininet has %i bidirectional links and " +
-                "ONOS has %i unidirectional links" %
-                ( len( mnLinks ), len( onos ) ) )
+                "Mininet has " + str( len( mnLinks ) ) +
+                " bidirectional links and ONOS has " +
+                str( len( onos ) ) + " unidirectional links" )
 
         # iterate through MN links and check if an ONOS link exists in
         # both directions
diff --git a/TestON/drivers/common/cli/onosclidriver.py b/TestON/drivers/common/cli/onosclidriver.py
index f30289f..097a303 100644
--- a/TestON/drivers/common/cli/onosclidriver.py
+++ b/TestON/drivers/common/cli/onosclidriver.py
@@ -201,8 +201,8 @@
                 main.log.info( str( ONOSIp ) + " CLI Started successfully" )
                 if karafTimeout:
                     self.handle.sendline(
-                        "config:property-set -p org.apache.karaf.shel\
-                                l sshIdleTimeout " +
+                        "config:property-set -p org.apache.karaf.shell\
+                                 sshIdleTimeout " +
                         karafTimeout )
                     self.handle.expect( "\$" )
                     self.handle.sendline( "onos -w " + str( ONOSIp ) )
@@ -868,9 +868,14 @@
             cmdStr = "add-host-intent " + str( hostIdOne ) +\
                 " " + str( hostIdTwo )
             handle = self.sendline( cmdStr )
-            main.log.info( "Host intent installed between " +
+            if re.search( "Error", handle ):
+                main.log.error( "Error in adding Host intent" )
+                return handle
+            else:
+                main.log.info( "Host intent installed between " +
                            str( hostIdOne ) + " and " + str( hostIdTwo ) )
-            return handle
+                return main.TRUE
+
         except pexpect.EOF:
             main.log.error( self.name + ": EOF exception found" )
             main.log.error( self.name + ":    " + self.handle.before )
diff --git a/TestON/drivers/common/cli/quaggaclidriver.py b/TestON/drivers/common/cli/quaggaclidriver.py
index 8724454..98f83d2 100644
--- a/TestON/drivers/common/cli/quaggaclidriver.py
+++ b/TestON/drivers/common/cli/quaggaclidriver.py
@@ -28,19 +28,14 @@
         # self.handle = super( QuaggaCliDriver,self ).connect(
         # user_name=self.user_name, ip_address=self.ip_address,port=self.port,
         # pwd=self.pwd )
-        self.handle = super(
-            QuaggaCliDriver,
-            self ).connect(
+        self.handle = super( QuaggaCliDriver, self ).connect(
                 user_name=self.user_name,
-            ip_address="1.1.1.1",
-            port=self.port,
-            pwd=self.pwd )
-        main.log.info(
-            "connect parameters:" + str(
-                self.user_name ) + ";" + str(
-                    self.ip_address ) + ";" + str(
-                self.port ) + ";" + str(
-                self.pwd ) )
+                ip_address="1.1.1.1",
+                port=self.port,
+                pwd=self.pwd )
+        main.log.info( "connect parameters:" + str( self.user_name ) + ";"
+                       + str( self.ip_address ) + ";" + str( self.port )
+                       + ";" + str(self.pwd ) )
 
         if self.handle:
             # self.handle.expect( "",timeout=10 )
@@ -64,14 +59,9 @@
         self.handle = super( QuaggaCliDriver, self ).connect(
             user_name=self.user_name, ip_address=ip_address,
             port=self.port, pwd=self.pwd )
-        main.log.info( "connect parameters:" +
-                       str( self.user_name ) +
-                       ";" +
-                       str( self.ip_address ) +
-                       ";" +
-                       str( self.port ) +
-                       ";" +
-                       str( self.pwd ) )
+        main.log.info( "connect parameters:" + str( self.user_name ) + ";"
+                       + str( self.ip_address ) + ";" + str( self.port )
+                       + ";" + str( self.pwd ) )
 
         if self.handle:
             # self.handle.expect( "" )
@@ -85,7 +75,7 @@
             self.handle.sendline( "enable" )
             # self.handle.expect( "bgpd#", timeout=5 )
             self.handle.expect( "bgpd#" )
-            main.log.info( "I in quagga on host " + str( ip_address ) )
+            main.log.info( "I am in quagga on host " + str( ip_address ) )
 
             return self.handle
         else:
@@ -114,8 +104,7 @@
     def generatePrefixes( self, net, numRoutes ):
         main.log.info( "I am in generate_prefixes method!" )
 
-        # each IP prefix will be composed by
-        #"net" + "." + m + "." + n + "." + x
+        # each IP prefix is composed by "net" + "." + m + "." + n + "." + x
         # the length of each IP prefix is 24
         routes = []
         routesGen = 0
@@ -124,10 +113,8 @@
 
         for i in range( 0, m ):
             for j in range( 0, 256 ):
-                network = str(
-                    net ) + "." + str(
-                        i ) + "." + str(
-                            j ) + ".0/24"
+                network = str( net ) + "." + str( i ) + "." + str( j ) \
+                    + ".0/24"
                 routes.append( network )
                 routesGen = routesGen + 1
 
@@ -144,39 +131,36 @@
 
     # This method generates a multiple to single point intent(
     # MultiPointToSinglePointIntent ) for a given route
-    def generateExpectedSingleRouteIntent(
-            self,
-            prefix,
-            nextHop,
-            nextHopMac,
-            sdnipData ):
+    def generateExpectedSingleRouteIntent( self, prefix, nextHop, nextHopMac,
+                                           sdnipData ):
 
-        ingress = []
+        ingresses = []
         egress = ""
         for peer in sdnipData[ 'bgpPeers' ]:
-            if peer[ 'ip_address' ] == nextHop:
-                egress = "of:" + \
-                    str( peer[ 'attachmentDpid' ] ).replace( ":", "" ) + ":" +\
-                    str( peer[ 'attachmentPort' ] )
-            else:
-                ingress.append( "of:" +
-                                str( peer[ 'attachmentDpid' ] ).replace( ":",
-                                     "" ) + ":" +
-                                str( peer[ 'attachmentPort' ] ) )
+            if peer[ 'ipAddress' ] == nextHop:
+                egress = "of:" + str(
+                    peer[ 'attachmentDpid' ] ).replace( ":", "" ) + ":" \
+                    + str( peer[ 'attachmentPort' ] )
+        for peer in sdnipData[ 'bgpPeers' ]:
+            if not peer[ 'ipAddress' ] == nextHop:
+                ingress = "of:" + str(
+                    peer[ 'attachmentDpid' ] ).replace( ":", "" ) + ":" \
+                    + str( peer[ 'attachmentPort' ] )
+                if not ingress == egress and ingress not in ingresses:
+                    ingresses.append( ingress )
+                    # ingresses.append( "of:" + str( peer[ 'attachmentDpid' ]
+                    # ).replace( ":", "" ) + ":" + str( peer[ 'attachmentPort'
+                    # ] ) )
 
         selector = "ETH_TYPE{ethType=800},IPV4_DST{ip=" + prefix + "}"
         treatment = "[ETH_DST{mac=" + str( nextHopMac ) + "}]"
 
-        intent = egress + "/" + \
-            str( sorted( ingress ) ) + "/" + selector + "/" + treatment
+        intent = egress + "/" + str( sorted( ingresses ) ) + "/" + \
+            selector + "/" + treatment
         return intent
 
-    def generateExpectedOnePeerRouteIntents(
-            self,
-            prefixes,
-            nextHop,
-            nextHopMac,
-            sdnipJsonFilePath ):
+    def generateExpectedOnePeerRouteIntents( self, prefixes, nextHop,
+                                             nextHopMac, sdnipJsonFilePath ):
         intents = []
         sdnipJsonFile = open( sdnipJsonFilePath ).read()
 
@@ -185,10 +169,7 @@
         for prefix in prefixes:
             intents.append(
                 self.generateExpectedSingleRouteIntent(
-                    prefix,
-                    nextHop,
-                    nextHopMac,
-                    sdnipData ) )
+                    prefix, nextHop, nextHopMac, sdnipData ) )
         return sorted( intents )
 
     # TODO
@@ -220,14 +201,15 @@
         for intent in intentsJsonObj:
             if intent[ 'appId' ] != "org.onosproject.sdnip":
                 continue
-            if intent[ 'type' ] == "MultiPointToSinglePointIntent" and intent[
-                    'state' ] == 'INSTALLED':
-                egress = str( intent[ 'egress' ][ 'device' ] ) + ":" + str(
-                    intent[ 'egress' ][ 'port' ] )
+            if intent[ 'type' ] == "MultiPointToSinglePointIntent" \
+            and intent[ 'state' ] == 'INSTALLED':
+                egress = str( intent[ 'egress' ][ 'device' ] ) + ":" \
+                    + str( intent[ 'egress' ][ 'port' ] )
                 ingress = []
                 for attachmentPoint in intent[ 'ingress' ]:
-                    ingress.append( str( attachmentPoint[ 'device' ] ) +
-                            ":" + str( attachmentPoint[ 'port' ] ) )
+                    ingress.append(
+                        str( attachmentPoint[ 'device' ] ) + ":"
+                        + str( attachmentPoint[ 'port' ] ) )
 
                 selector = intent[ 'selector' ].replace(
                     "[", "" ).replace( "]", "" ).replace( " ", "" )
@@ -235,8 +217,7 @@
                     str1, str2 = str( selector ).split( "," )
                     selector = str2 + "," + str1
 
-                intent = egress + "/" + \
-                    str( sorted( ingress ) ) + "/" + \
+                intent = egress + "/" + str( sorted( ingress ) ) + "/" + \
                     selector + "/" + intent[ 'treatment' ]
                 intents.append( intent )
         return sorted( intents )
@@ -251,22 +232,16 @@
         for intent in intentsJsonObj:
             if intent[ 'appId' ] != "org.onosproject.sdnip":
                 continue
-            if intent[ 'type' ] == "PointToPointIntent" and "protocol=6"\
-                    in str(  intent[ 'selector' ] ):
-                ingress = str( intent[ 'ingress' ][ 'device' ] ) + ":" + str(
-                    intent[ 'ingress' ][ 'port' ] )
-                egress = str( intent[ 'egress' ][ 'device' ] ) + ":" + str(
-                    intent[ 'egress' ][ 'port' ] )
-                selector = str(
-                    intent[ 'selector' ] ).replace(
-                    " ",
-                    "" ).replace(
-                    "[",
-                    "" ).replace(
-                    "]",
-                    "" ).split( "," )
-                intent = ingress + "/" + egress + \
-                    "/" + str( sorted( selector ) )
+            if intent[ 'type' ] == "PointToPointIntent" \
+            and "protocol=6" in str( intent[ 'selector' ] ):
+                ingress = str( intent[ 'ingress' ][ 'device' ] ) + ":" \
+                    + str( intent[ 'ingress' ][ 'port' ] )
+                egress = str( intent[ 'egress' ][ 'device' ] ) + ":" + \
+                    str( intent[ 'egress' ][ 'port' ] )
+                selector = str( intent[ 'selector' ] ).replace( " ", "" )\
+                    .replace( "[", "" ).replace( "]", "" ).split( "," )
+                intent = ingress + "/" + egress + "/" + \
+                    str( sorted( selector ) )
                 intents.append( intent )
 
         return sorted( intents )
@@ -282,73 +257,72 @@
         intents = []
         bgpPeerAttachmentPoint = ""
         bgpSpeakerAttachmentPoint = "of:" + str(
-            sdnipData[ 'bgpSpeakers' ][ 0 ][ 'attachmentDpid' ] ).replace( ":",
-             "" ) + ":" +\
-                     str( sdnipData[ 'bgpSpeakers' ][ 0 ][ 'attachmentPort' ] )
+            sdnipData[ 'bgpSpeakers' ][ 0 ][ 'attachmentDpid' ] )\
+            .replace( ":", "" ) + ":" \
+            + str( sdnipData[ 'bgpSpeakers' ][ 0 ][ 'attachmentPort' ] )
         for peer in sdnipData[ 'bgpPeers' ]:
-            bgpPeerAttachmentPoint = "of:" + \
-                str( peer[ 'attachmentDpid' ] ).replace( ":", "" ) +\
-                ":" + str( peer[ 'attachmentPort' ] )
+            bgpPeerAttachmentPoint = "of:" \
+                + str( peer[ 'attachmentDpid' ] ).replace( ":", "" ) \
+                + ":" + str( peer[ 'attachmentPort' ] )
             # find out the BGP speaker IP address for this BGP peer
             bgpSpeakerIpAddress = ""
-            for interfaceAddress in sdnipData[
-                    'bgpSpeakers' ][ 0 ][ 'interfaceAddresses' ]:
+            for interfaceAddress in \
+            sdnipData[ 'bgpSpeakers' ][ 0 ][ 'interfaceAddresses' ]:
                 # if eq( interfaceAddress[ 'interfaceDpid' ],sdnipData[
                 # 'bgpSpeakers' ][ 0 ][ 'attachmentDpid' ] ) and eq(
-                # interfaceAddress[ 'interfacePort' ], sdnipData[
-                # 'bgpSpeakers' ][ 0 ][ 'attachmentPort' ] ):
-                if eq(
-                        interfaceAddress[ 'interfaceDpid' ],
-                        peer[ 'attachmentDpid' ] ) and eq(
-                        interfaceAddress[ 'interfacePort' ],
+                # interfaceAddress[ 'interfacePort' ], sdnipData[ 'bgpSpeakers'
+                # ][ 0 ][ 'attachmentPort' ] ):
+                if eq( interfaceAddress[ 'interfaceDpid' ],
+                       peer[ 'attachmentDpid' ] ) \
+                and eq( interfaceAddress[ 'interfacePort' ],
                         peer[ 'attachmentPort' ] ):
-                    bgpSpeakerIpAddress = interfaceAddress[ 'ip_address' ]
+                    bgpSpeakerIpAddress = interfaceAddress[ 'ipAddress' ]
                     break
                 else:
                     continue
 
             # from bgpSpeakerAttachmentPoint to bgpPeerAttachmentPoint
             # direction
-            selectorStr = "IPV4_SRC{ip=" + bgpSpeakerIpAddress +\
-                    "/32}," + "IPV4_DST{ip=" + peer[ 'ip_address' ] + "/32}," +\
-                        "IP_PROTO{protocol=6}, ETH_TYPE{ethType=800},\
-                        TCP_DST{tcpPort=179}"
-            selector = selectorStr.replace( " ", "" ).replace(
-                "[", "" ).replace( "]", "" ).split( "," )
+            selectorStr = "IPV4_SRC{ip=" + bgpSpeakerIpAddress + "/32}," \
+                + "IPV4_DST{ip=" + peer[ 'ipAddress' ] + "/32}," \
+                + "IP_PROTO{protocol=6}, ETH_TYPE{ethType=800}, \
+                TCP_DST{tcpPort=179}"
+            selector = selectorStr.replace( " ", "" ).replace("[", "" )\
+                .replace( "]", "" ).split( "," )
             intent = bgpSpeakerAttachmentPoint + "/" + \
                 bgpPeerAttachmentPoint + "/" + str( sorted( selector ) )
             intents.append( intent )
 
-            selectorStr = "IPV4_SRC{ip=" + bgpSpeakerIpAddress + "/32}," +\
-                    "IPV4_DST{ip=" + peer[ 'ip_address' ] + "/32}," +\
-                    "IP_PROTO{protocol=6}, ETH_TYPE{ethType=800},\
-                    TCP_SRC{tcpPort=179}"
-            selector = selectorStr.replace( " ", "" ).replace(
-                "[", "" ).replace( "]", "" ).split( "," )
-            intent = bgpSpeakerAttachmentPoint + "/" + \
-                bgpPeerAttachmentPoint + "/" + str( sorted( selector ) )
+            selectorStr = "IPV4_SRC{ip=" + bgpSpeakerIpAddress + "/32}," \
+                + "IPV4_DST{ip=" + peer[ 'ipAddress' ] + "/32}," \
+                + "IP_PROTO{protocol=6}, ETH_TYPE{ethType=800}, \
+                TCP_SRC{tcpPort=179}"
+            selector = selectorStr.replace( " ", "" ).replace("[", "" )\
+                .replace( "]", "" ).split( "," )
+            intent = bgpSpeakerAttachmentPoint + "/" \
+                + bgpPeerAttachmentPoint + "/" + str( sorted( selector ) )
             intents.append( intent )
 
             # from bgpPeerAttachmentPoint to bgpSpeakerAttachmentPoint
             # direction
-            selectorStr = "IPV4_SRC{ip=" + peer[ 'ip_address' ] + "/32}," +\
-                    "IPV4_DST{ip=" + bgpSpeakerIpAddress + "/32}," + \
-                    "IP_PROTO{protocol=6}, ETH_TYPE{ethType=800},\
-                    TCP_DST{tcpPort=179}"
-            selector = selectorStr.replace( " ", "" ).replace(
-                "[", "" ).replace( "]", "" ).split( "," )
-            intent = bgpPeerAttachmentPoint + "/" + \
-                bgpSpeakerAttachmentPoint + "/" + str( sorted( selector ) )
+            selectorStr = "IPV4_SRC{ip=" + peer[ 'ipAddress' ] + "/32}," \
+                + "IPV4_DST{ip=" + bgpSpeakerIpAddress + "/32}," \
+                + "IP_PROTO{protocol=6}, ETH_TYPE{ethType=800}, \
+                TCP_DST{tcpPort=179}"
+            selector = selectorStr.replace( " ", "" ).replace("[", "" )\
+                .replace( "]", "" ).split( "," )
+            intent = bgpPeerAttachmentPoint + "/" \
+                + bgpSpeakerAttachmentPoint + "/" + str( sorted( selector ) )
             intents.append( intent )
 
-            selectorStr = "IPV4_SRC{ip=" + peer[ 'ip_address' ] + "/32}," +\
-                    "IPV4_DST{ip=" + bgpSpeakerIpAddress + "/32}," +\
-                    "IP_PROTO{protocol=6}, ETH_TYPE{ethType=800},\
-                     TCP_SRC{tcpPort=179}"
-            selector = selectorStr.replace( " ", "" ).replace(
-                "[", "" ).replace( "]", "" ).split( "," )
-            intent = bgpPeerAttachmentPoint + "/" + \
-                bgpSpeakerAttachmentPoint + "/" + str( sorted( selector ) )
+            selectorStr = "IPV4_SRC{ip=" + peer[ 'ipAddress' ] + "/32}," \
+                + "IPV4_DST{ip=" + bgpSpeakerIpAddress + "/32}," \
+                + "IP_PROTO{protocol=6}, ETH_TYPE{ethType=800}, \
+                TCP_SRC{tcpPort=179}"
+            selector = selectorStr.replace( " ", "" ).replace( "[", "" )\
+                .replace( "]", "" ).split( "," )
+            intent = bgpPeerAttachmentPoint + "/" \
+                + bgpSpeakerAttachmentPoint + "/" + str( sorted( selector ) )
             intents.append( intent )
 
         return sorted( intents )
@@ -374,8 +348,8 @@
             except:
                 main.log.warn( "Failed to add route" )
                 self.disconnect()
-            waitTimer = 1.00 / routeRate
-            time.sleep( waitTimer )
+            # waitTimer = 1.00 / routeRate
+            # time.sleep( waitTimer )
         if routesAdded == len( routes ):
             main.log.info( "Finished adding routes" )
             return main.TRUE
@@ -400,10 +374,10 @@
                 self.handle.sendline( routeCmd )
                 self.handle.expect( "bgpd", timeout=5 )
             except:
-                main.log.warn( "Failed to add route" )
+                main.log.warn( "Failed to delete route" )
                 self.disconnect()
-            waitTimer = 1.00 / routeRate
-            time.sleep( waitTimer )
+            # waitTimer = 1.00 / routeRate
+            # time.sleep( waitTimer )
         if routesAdded == len( routes ):
             main.log.info( "Finished deleting routes" )
             return main.TRUE
@@ -416,24 +390,15 @@
         self.handle = super( QuaggaCliDriver, self ).connect(
             user_name=self.user_name, ip_address=ip_address,
             port=self.port, pwd=self.pwd )
-        main.log.info( "connect parameters:" +
-                       str( self.user_name ) +
-                       ";" +
-                       str( self.ip_address ) +
-                       ";" +
-                       str( self.port ) +
-                       ";" +
-                       str( self.pwd ) )
+        main.log.info( "connect parameters:" + str( self.user_name ) + ";"
+                       + str( self.ip_address ) + ";" + str( self.port )
+                       + ";" + str( self.pwd ) )
 
         if self.handle:
             # self.handle.expect( "" )
             # self.handle.expect( "\$" )
             main.log.info( "I in host " + str( ip_address ) )
-            main.log.info(
-                pingTestFile +
-                " > " +
-                pingTestResultFile +
-                " &" )
+            main.log.info( pingTestFile + " > " + pingTestResultFile + " &" )
             self.handle.sendline(
                 pingTestFile +
                 " > " +
@@ -447,7 +412,7 @@
             main.log.info( "NO HANDLE" )
             return main.FALSE
 
-    # Please use the generateRoutes plus addRoutes instead of this one
+    # Please use the generateRoutes plus addRoutes instead of this one!
     def addRoute( self, net, numRoutes, routeRate ):
         try:
             self.handle.sendline( "" )
@@ -467,8 +432,8 @@
             numRoutes = 255
         for m in range( 1, j + 1 ):
             for n in range( 1, numRoutes + 1 ):
-                network = str( net ) + "." + str( m ) + \
-                              "." + str( n ) + ".0/24"
+                network = str( net ) + "." + str( m ) + "." + str( n ) \
+                    + ".0/24"
                 routeCmd = "network " + network
                 try:
                     self.handle.sendline( routeCmd )
@@ -481,10 +446,8 @@
                 routesAdded = routesAdded + 1
         for d in range( j + 1, j + 2 ):
             for e in range( 1, k + 1 ):
-                network = str(
-                    net ) + "." + str(
-                        d ) + "." + str(
-                            e ) + ".0/24"
+                network = str( net ) + "." + str( d ) + "." + str( e ) \
+                    + ".0/24"
                 routeCmd = "network " + network
                 try:
                     self.handle.sendline( routeCmd )
@@ -498,7 +461,8 @@
         if routesAdded == numRoutes:
             return main.TRUE
         return main.FALSE
-
+    
+    # Please use deleteRoutes method instead of this one!
     def delRoute( self, net, numRoutes, routeRate ):
         try:
             self.handle.sendline( "" )
@@ -518,8 +482,8 @@
             numRoutes = 255
         for m in range( 1, j + 1 ):
             for n in range( 1, numRoutes + 1 ):
-                network = str( net ) + "." + str( m ) + \
-                              "." + str( n ) + ".0/24"
+                network = str( net ) + "." + str( m ) + "." + str( n ) \
+                    + ".0/24"
                 routeCmd = "no network " + network
                 try:
                     self.handle.sendline( routeCmd )
@@ -532,8 +496,8 @@
                 routesDeleted = routesDeleted + 1
         for d in range( j + 1, j + 2 ):
             for e in range( 1, k + 1 ):
-                network = str( net ) + "." + str( d ) + \
-                              "." + str( e ) + ".0/24"
+                network = str( net ) + "." + str( d ) + "." + str( e ) \
+                    + ".0/24"
                 routeCmd = "no network " + network
                 try:
                     self.handle.sendline( routeCmd )
@@ -554,7 +518,7 @@
             child = pexpect.spawn( "telnet " + ip )
             i = child.expect( [ "login:", "CLI#", pexpect.TIMEOUT ] )
             if i == 0:
-                print "Username and password required. Passing login info."
+                print "user_name and password required. Passing login info."
                 child.sendline( user )
                 child.expect( "Password:" )
                 child.sendline( passwd )
@@ -570,10 +534,8 @@
             child.expect( "Flow table show" )
             count = 0
             while True:
-                i = child.expect(
-                    [ '17\d\.\d{1,3}\.\d{1,3}\.\d{1,3}',
-                      'CLI#',
-                      pexpect.TIMEOUT ] )
+                i = child.expect( [ '17\d\.\d{1,3}\.\d{1,3}\.\d{1,3}', 
+                                   'CLI#', pexpect.TIMEOUT ] )
                 if i == 0:
                     count = count + 1
                 elif i == 1:
@@ -620,3 +582,4 @@
             main.log.error( "Connection failed to the host" )
             response = main.FALSE
         return response
+
diff --git a/TestON/drivers/common/clidriver.py b/TestON/drivers/common/clidriver.py
index 6d7fb2a..1b8998b 100644
--- a/TestON/drivers/common/clidriver.py
+++ b/TestON/drivers/common/clidriver.py
@@ -81,7 +81,7 @@
         while i == 5:
             i = self.handle.expect( [
 				    ssh_newkey,
-                                    'password:',
+                                    'password:|\$',
                                     pexpect.EOF,
                                     pexpect.TIMEOUT,
                                     refused,
diff --git a/TestON/tests/FuncNext13/FuncNext13.params b/TestON/tests/FuncNext13/FuncNext13.params
new file mode 100755
index 0000000..13a4691
--- /dev/null
+++ b/TestON/tests/FuncNext13/FuncNext13.params
@@ -0,0 +1,37 @@
+<PARAMS>
+    
+    <testcases>1,4,5,3</testcases>
+
+    #Environment variables
+    <ENV>
+        <cellName>driver_test</cellName>
+    </ENV>
+
+    <CTRL>
+        <ip1>10.128.20.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>
+</PARAMS>
diff --git a/TestON/tests/FuncNext13/FuncNext13.py b/TestON/tests/FuncNext13/FuncNext13.py
new file mode 100755
index 0000000..6b24695
--- /dev/null
+++ b/TestON/tests/FuncNext13/FuncNext13.py
@@ -0,0 +1,608 @@
+
+#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 FuncNext13:
+    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 == 1:
+            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/FuncNext13/FuncNext13.topo b/TestON/tests/FuncNext13/FuncNext13.topo
new file mode 100755
index 0000000..85b6cab
--- /dev/null
+++ b/TestON/tests/FuncNext13/FuncNext13.topo
@@ -0,0 +1,61 @@
+<TOPOLOGY>
+    <COMPONENT>
+
+        <ONOSbench>
+            <host>10.128.10.11</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosDriver</type>
+            <connect_order>1</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOSbench>
+
+        <ONOS1>
+            <host>10.128.10.11</host>
+            <user>sdn</user>
+            <password>sdn</password>
+            <type>OnosDriver</type>
+            <connect_order>2</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOS1>
+
+        <ONOS2>
+            <host>10.128.10.11</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosCliDriver</type>
+            <connect_order>3</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOS2>
+
+        <Mininet1>
+            <host>10.128.10.11</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=OpenFlow13</arg3>
+                <controller> remote </controller>
+            </COMPONENTS>
+        </Mininet1>
+
+        <Mininet2>
+            <host>10.128.10.11</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=OpenFlow13 </arg3>
+                <controller> remote </controller>
+            </COMPONENTS>
+        </Mininet2>
+    </COMPONENT>
+</TOPOLOGY>
diff --git a/TestON/tests/FuncNext13/__init__.py b/TestON/tests/FuncNext13/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/TestON/tests/FuncNext13/__init__.py
diff --git a/TestON/tests/HATestClusterRestart/HATestClusterRestart.params b/TestON/tests/HATestClusterRestart/HATestClusterRestart.params
index 7556184..6f2002d 100644
--- a/TestON/tests/HATestClusterRestart/HATestClusterRestart.params
+++ b/TestON/tests/HATestClusterRestart/HATestClusterRestart.params
@@ -4,6 +4,7 @@
     <cellName>HA</cellName>
     </ENV>
     <Git>False</Git>
+    <branch> master </branch>
     <num_controllers> 7 </num_controllers>
 
     <CTRL>
diff --git a/TestON/tests/HATestClusterRestart/HATestClusterRestart.py b/TestON/tests/HATestClusterRestart/HATestClusterRestart.py
index 2b28907..791d55c 100644
--- a/TestON/tests/HATestClusterRestart/HATestClusterRestart.py
+++ b/TestON/tests/HATestClusterRestart/HATestClusterRestart.py
@@ -49,7 +49,7 @@
         PULLCODE = False
         if main.params[ 'Git' ] == 'True':
             PULLCODE = True
-
+        gitBranch = main.params[ 'branch' ]
         cellName = main.params[ 'ENV' ][ 'cellName' ]
 
         # set global variables
@@ -108,18 +108,15 @@
         if PULLCODE:
             # TODO Configure branch in params
             main.step( "Git checkout and pull master" )
-            main.ONOSbench.gitCheckout( "master" )
+            main.ONOSbench.gitCheckout( gitBranch )
             gitPullResult = main.ONOSbench.gitPull()
 
             main.step( "Using mvn clean & install" )
-            cleanInstallResult = main.TRUE
-        # In Sanity test, always re-compile ONOS
-        if gitPullResult == main.TRUE:
             cleanInstallResult = main.ONOSbench.cleanInstall()
         else:
             main.log.warn( "Did not pull new code so skipping mvn " +
                            "clean install" )
-        main.ONOSbench.getVersion( report=True )
+    main.ONOSbench.getVersion( report=True )
 
         main.step( "Creating ONOS package" )
         packageResult = main.ONOSbench.onosPackage()
@@ -385,7 +382,6 @@
     def CASE3( self, main ):
         """
         Assign intents
-
         """
         # FIXME: we must reinstall intents until we have a persistant
         # datastore!
@@ -410,6 +406,11 @@
         pingResult = main.FALSE
         time1 = time.time()
         pingResult = main.Mininet1.pingall()
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=pingResult,
+            onpass="Reactive Pingall test passed",
+            onfail="Reactive Pingall failed, one or more ping pairs failed" )
         time2 = time.time()
         main.log.info( "Time for pingall: %2f seconds" % ( time2 - time1 ) )
 
@@ -447,11 +448,12 @@
                 tmpResult = main.FALSE
             intentAddResult = bool( pingResult and intentAddResult
                                      and tmpResult )
+            # TODO Check that intents were added?
         utilities.assert_equals(
             expect=True,
             actual=intentAddResult,
-            onpass="Switch mastership correctly assigned",
-            onfail="Error in ( re )assigning switch mastership" )
+            onpass="Pushed host intents to ONOS",
+            onfail="Error in pushing host intents to ONOS" )
         # TODO Check if intents all exist in datastore
 
     def CASE4( self, main ):
@@ -475,6 +477,12 @@
         if PingResult == main.FALSE:
             main.log.report(
                 "Intents have not been installed correctly, pings failed." )
+            #TODO: pretty print
+            main.log.warn( "ONSO1 intents: " )
+            main.log.warn( json.dumps( json.loads( main.ONOScli1.intents() ),
+                                       sort_keys=True,
+                                       indent=4,
+                                       separators=( ',', ': ' ) ) )
         if PingResult == main.TRUE:
             main.log.report(
                 "Intents have been installed correctly and verified by pings" )
@@ -924,23 +932,7 @@
         clusters.append( main.ONOScli5.clusters() )
         clusters.append( main.ONOScli6.clusters() )
         clusters.append( main.ONOScli7.clusters() )
-        paths = []
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli1.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli2.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli3.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli4.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli5.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli6.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli7.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-
-        # Compare json objects for hosts, dataplane clusters and paths
+        # Compare json objects for hosts and dataplane clusters
 
         # hosts
         consistentHostsResult = main.TRUE
@@ -1003,30 +995,6 @@
             str( numClusters ) +
             " SCCs" )
 
-        # paths
-        consistentPathsResult = main.TRUE
-        for controller in range( len( paths ) ):
-            controllerStr = str( controller + 1 )
-            if "Error" not in paths[ controller ]:
-                if paths[ controller ] == paths[ 0 ]:
-                    continue
-                else:  # paths not consistent
-                    main.log.report( "paths from ONOS" + controllerStr +
-                                     " is inconsistent with ONOS1" )
-                    consistentPathsResult = main.FALSE
-
-            else:
-                main.log.report( "Error in getting paths from ONOS" +
-                                 controllerStr )
-                consistentPathsResult = main.FALSE
-                main.log.warn( "ONOS" + controllerStr + " paths response: " +
-                               repr( paths[ controller ] ) )
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=consistentPathsResult,
-            onpass="Paths count is consistent across all ONOS nodes",
-            onfail="ONOS nodes have different counts of paths" )
-
         main.step( "Comparing ONOS topology to MN" )
         devicesResults = main.TRUE
         portsResults = main.TRUE
@@ -1080,8 +1048,7 @@
             linksResults = linksResults and currentLinksResult
 
         topoResult = devicesResults and portsResults and linksResults\
-            and consistentHostsResult and consistentClustersResult\
-            and consistentPathsResult
+            and consistentHostsResult and consistentClustersResult
         utilities.assert_equals( expect=main.TRUE, actual=topoResult,
                                 onpass="Topology Check Test successful",
                                 onfail="Topology Check Test NOT successful" )
@@ -1509,13 +1476,21 @@
             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 ) ):
+                controllerStr = str( controller + 1 )
+                for host in hosts[ controller ]:
+                    host
+                    if host[ 'ips' ] == []:
+                        main.log.error(
+                            "DEBUG:Error with host ips on controller" +
+                            controllerStr + ": " + str( host ) )
             ports = []
             ports.append( main.ONOScli1.ports() )
             ports.append( main.ONOScli2.ports() )
@@ -1540,21 +1515,6 @@
             clusters.append( main.ONOScli5.clusters() )
             clusters.append( main.ONOScli6.clusters() )
             clusters.append( main.ONOScli7.clusters() )
-            paths = []
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli1.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli2.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli3.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli4.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli5.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli6.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli7.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
 
             elapsed = time.time() - startTime
             cliTime = time.time() - cliStart
@@ -1608,7 +1568,7 @@
             portsResults = portsResults and currentPortsResult
             linksResults = linksResults and currentLinksResult
 
-            # Compare json objects for hosts, dataplane clusters and paths
+            # Compare json objects for hosts and dataplane clusters
 
             # hosts
             consistentHostsResult = main.TRUE
@@ -1671,35 +1631,9 @@
                 str( numClusters ) +
                 " SCCs" )
 
-            # paths
-            consistentPathsResult = main.TRUE
-            for controller in range( len( paths ) ):
-                controllerStr = str( controller + 1 )
-                if "Error" not in paths[ controller ]:
-                    if paths[ controller ] == paths[ 0 ]:
-                        continue
-                    else:  # paths not consistent
-                        main.log.report( "paths from ONOS" + controllerStr +
-                                         " is inconsistent with ONOS1" )
-                        consistentPathsResult = main.FALSE
-
-                else:
-                    main.log.report( "Error in getting paths from ONOS" +
-                                     controllerStr )
-                    consistentPathsResult = main.FALSE
-                    main.log.warn( "ONOS" + controllerStr +
-                                   " paths response: " +
-                                   repr( paths[ controller ] ) )
-            utilities.assert_equals(
-                expect=main.TRUE,
-                actual=consistentPathsResult,
-                onpass="Paths count is consistent across all ONOS nodes",
-                onfail="ONOS nodes have different counts of paths" )
-
             topoResult = ( devicesResults and portsResults and linksResults
                            and consistentHostsResult
-                           and consistentClustersResult
-                           and consistentPathsResult )
+                           and consistentClustersResult )
 
         topoResult = topoResult and int( count <= 2 )
         note = "note it takes about " + str( int( cliTime ) ) + \
diff --git a/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.params b/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.params
index cf0ca61..7d79860 100644
--- a/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.params
+++ b/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.params
@@ -4,6 +4,7 @@
     <cellName>HA</cellName>
     </ENV>
     <Git>False</Git>
+    <branch> master </branch>
     <num_controllers> 7 </num_controllers>
 
     <CTRL>
diff --git a/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.py b/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.py
index 7517827..6cca54b 100644
--- a/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.py
+++ b/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.py
@@ -49,7 +49,7 @@
         PULLCODE = False
         if main.params[ 'Git' ] == 'True':
             PULLCODE = True
-
+        gitBranch = main.params[ 'branch' ]
         cellName = main.params[ 'ENV' ][ 'cellName' ]
 
         # set global variables
@@ -108,17 +108,14 @@
         if PULLCODE:
             # TODO Configure branch in params
             main.step( "Git checkout and pull master" )
-            main.ONOSbench.gitCheckout( "master" )
+            main.ONOSbench.gitCheckout( gitBranch )
             gitPullResult = main.ONOSbench.gitPull()
 
             main.step( "Using mvn clean & install" )
-            cleanInstallResult = main.TRUE
-
-            if gitPullResult == main.TRUE:
-                cleanInstallResult = main.ONOSbench.cleanInstall()
-            else:
-                main.log.warn( "Did not pull new code so skipping mvn " +
-                               "clean install" )
+            cleanInstallResult = main.ONOSbench.cleanInstall()
+        else:
+            main.log.warn( "Did not pull new code so skipping mvn " +
+                           "clean install" )
         main.ONOSbench.getVersion( report=True )
 
         main.step( "Creating ONOS package" )
@@ -385,7 +382,6 @@
     def CASE3( self, main ):
         """
         Assign intents
-
         """
         import time
         main.log.report( "Adding host intents" )
@@ -408,6 +404,11 @@
         pingResult = main.FALSE
         time1 = time.time()
         pingResult = main.Mininet1.pingall()
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=pingResult,
+            onpass="Reactive Pingall test passed",
+            onfail="Reactive Pingall failed, one or more ping pairs failed" )
         time2 = time.time()
         main.log.info( "Time for pingall: %2f seconds" % ( time2 - time1 ) )
 
@@ -445,11 +446,12 @@
                 tmpResult = main.FALSE
             intentAddResult = bool( pingResult and intentAddResult
                                      and tmpResult )
+            # TODO Check that intents were added?
         utilities.assert_equals(
             expect=True,
             actual=intentAddResult,
-            onpass="Switch mastership correctly assigned",
-            onfail="Error in ( re )assigning switch mastership" )
+            onpass="Pushed host intents to ONOS",
+            onfail="Error in pushing host intents to ONOS" )
         # TODO Check if intents all exist in datastore
 
     def CASE4( self, main ):
@@ -473,6 +475,12 @@
         if PingResult == main.FALSE:
             main.log.report(
                 "Intents have not been installed correctly, pings failed." )
+            #TODO: pretty print
+            main.log.warn( "ONSO1 intents: " )
+            main.log.warn( json.dumps( json.loads( main.ONOScli1.intents() ),
+                                       sort_keys=True,
+                                       indent=4,
+                                       separators=( ',', ': ' ) ) )
         if PingResult == main.TRUE:
             main.log.report(
                 "Intents have been installed correctly and verified by pings" )
@@ -928,23 +936,7 @@
         clusters.append( main.ONOScli5.clusters() )
         clusters.append( main.ONOScli6.clusters() )
         clusters.append( main.ONOScli7.clusters() )
-        paths = []
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli1.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli2.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli3.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli4.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli5.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli6.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli7.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-
-        # Compare json objects for hosts, dataplane clusters and paths
+        # Compare json objects for hosts and dataplane clusters
 
         # hosts
         consistentHostsResult = main.TRUE
@@ -1007,30 +999,6 @@
             str( numClusters ) +
             " SCCs" )
 
-        # paths
-        consistentPathsResult = main.TRUE
-        for controller in range( len( paths ) ):
-            controllerStr = str( controller + 1 )
-            if "Error" not in paths[ controller ]:
-                if paths[ controller ] == paths[ 0 ]:
-                    continue
-                else:  # paths not consistent
-                    main.log.report( "paths from ONOS" + controllerStr +
-                                     " is inconsistent with ONOS1" )
-                    consistentPathsResult = main.FALSE
-
-            else:
-                main.log.report( "Error in getting paths from ONOS" +
-                                 controllerStr )
-                consistentPathsResult = main.FALSE
-                main.log.warn( "ONOS" + controllerStr + " paths response: " +
-                               repr( paths[ controller ] ) )
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=consistentPathsResult,
-            onpass="Paths count is consistent across all ONOS nodes",
-            onfail="ONOS nodes have different counts of paths" )
-
         main.step( "Comparing ONOS topology to MN" )
         devicesResults = main.TRUE
         portsResults = main.TRUE
@@ -1084,8 +1052,7 @@
             linksResults = linksResults and currentLinksResult
 
         topoResult = devicesResults and portsResults and linksResults\
-            and consistentHostsResult and consistentClustersResult\
-            and consistentPathsResult
+            and consistentHostsResult and consistentClustersResult
         utilities.assert_equals( expect=main.TRUE, actual=topoResult,
                                 onpass="Topology Check Test successful",
                                 onfail="Topology Check Test NOT successful" )
@@ -1549,21 +1516,6 @@
             clusters.append( main.ONOScli5.clusters() )
             clusters.append( main.ONOScli6.clusters() )
             clusters.append( main.ONOScli7.clusters() )
-            paths = []
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli1.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli2.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli3.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli4.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli5.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli6.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli7.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
 
             elapsed = time.time() - startTime
             cliTime = time.time() - cliStart
@@ -1617,7 +1569,7 @@
             portsResults = portsResults and currentPortsResult
             linksResults = linksResults and currentLinksResult
 
-            # Compare json objects for hosts, dataplane clusters and paths
+            # Compare json objects for hosts and dataplane clusters
 
             # hosts
             consistentHostsResult = main.TRUE
@@ -1680,35 +1632,9 @@
                 str( numClusters ) +
                 " SCCs" )
 
-            # paths
-            consistentPathsResult = main.TRUE
-            for controller in range( len( paths ) ):
-                controllerStr = str( controller + 1 )
-                if "Error" not in paths[ controller ]:
-                    if paths[ controller ] == paths[ 0 ]:
-                        continue
-                    else:  # paths not consistent
-                        main.log.report( "paths from ONOS" + controllerStr +
-                                         " is inconsistent with ONOS1" )
-                        consistentPathsResult = main.FALSE
-
-                else:
-                    main.log.report( "Error in getting paths from ONOS" +
-                                     controllerStr )
-                    consistentPathsResult = main.FALSE
-                    main.log.warn( "ONOS" + controllerStr +
-                                   " paths response: " +
-                                   repr( paths[ controller ] ) )
-            utilities.assert_equals(
-                expect=main.TRUE,
-                actual=consistentPathsResult,
-                onpass="Paths count is consistent across all ONOS nodes",
-                onfail="ONOS nodes have different counts of paths" )
-
             topoResult = ( devicesResults and portsResults and linksResults
                            and consistentHostsResult
-                           and consistentClustersResult
-                           and consistentPathsResult )
+                           and consistentClustersResult )
 
         topoResult = topoResult and int( count <= 2 )
         note = "note it takes about " + str( int( cliTime ) ) + \
diff --git a/TestON/tests/HATestSanity/HATestSanity.params b/TestON/tests/HATestSanity/HATestSanity.params
index bc44e59..ee4374d 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,14,[6],8,7,4,15,9,8,4,10,8,4,11,8,4,12,8,4,13</testcases>
     <ENV>
-    <cellName>HA</cellName>
+        <cellName>HA</cellName>
     </ENV>
-    <Git>True</Git>
+    <Git> True </Git>
+    <branch> master </branch>
     <num_controllers> 7 </num_controllers>
 
     <CTRL>
diff --git a/TestON/tests/HATestSanity/HATestSanity.py b/TestON/tests/HATestSanity/HATestSanity.py
index 16df59c..9a95e78 100644
--- a/TestON/tests/HATestSanity/HATestSanity.py
+++ b/TestON/tests/HATestSanity/HATestSanity.py
@@ -43,18 +43,13 @@
         """
         main.log.report( "ONOS HA Sanity test - initialization" )
         main.case( "Setting up test environment" )
-        # main.step( "This is a multiline \
-        #            comment\
-        #            this is \
-        #            a long \comment" )
-        print "First Line"
         # TODO: save all the timers and output them for plotting
 
         # load some vairables from the params file
         PULLCODE = False
         if main.params[ 'Git' ] == 'True':
             PULLCODE = True
-
+        gitBranch = main.params[ 'branch' ]
         cellName = main.params[ 'ENV' ][ 'cellName' ]
 
         # set global variables
@@ -113,17 +108,14 @@
         if PULLCODE:
             # TODO Configure branch in params
             main.step( "Git checkout and pull master" )
-            main.ONOSbench.gitCheckout( "master" )
+            main.ONOSbench.gitCheckout( gitBranch )
             gitPullResult = main.ONOSbench.gitPull()
 
             main.step( "Using mvn clean & install" )
-            cleanInstallResult = main.TRUE
-
-            if gitPullResult == main.TRUE:
-                cleanInstallResult = main.ONOSbench.cleanInstall()
-            else:
-                main.log.warn( "Did not pull new code so skipping mvn " +
-                               "clean install" )
+            cleanInstallResult = main.ONOSbench.cleanInstall()
+        else:
+            main.log.warn( "Did not pull new code so skipping mvn " +
+                           "clean install" )
         main.ONOSbench.getVersion( report=True )
 
         main.step( "Creating ONOS package" )
@@ -412,6 +404,11 @@
         pingResult = main.FALSE
         time1 = time.time()
         pingResult = main.Mininet1.pingall()
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=pingResult,
+            onpass="Reactive Pingall test passed",
+            onfail="Reactive Pingall failed, one or more ping pairs failed" )
         time2 = time.time()
         main.log.info( "Time for pingall: %2f seconds" % ( time2 - time1 ) )
 
@@ -478,7 +475,12 @@
         if PingResult == main.FALSE:
             main.log.report(
                 "Intents have not been installed correctly, pings failed." )
-            main.log.info( main.ONOScli1.intents() )
+            #TODO: pretty print
+            main.log.warn( "ONSO1 intents: " )
+            main.log.warn( json.dumps( json.loads( main.ONOScli1.intents() ),
+                                       sort_keys=True,
+                                       indent=4,
+                                       separators=( ',', ': ' ) ) )
         if PingResult == main.TRUE:
             main.log.report(
                 "Intents have been installed correctly and verified by pings" )
@@ -930,23 +932,7 @@
         clusters.append( main.ONOScli5.clusters() )
         clusters.append( main.ONOScli6.clusters() )
         clusters.append( main.ONOScli7.clusters() )
-        paths = []
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli1.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli2.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli3.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli4.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli5.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli6.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-        tempTopo = main.ONOSbench.getTopology( main.ONOScli7.topology() )
-        paths.append( tempTopo.get( 'paths', False ) )
-
-        # Compare json objects for hosts, dataplane clusters and paths
+        # Compare json objects for hosts and dataplane clusters
 
         # hosts
         consistentHostsResult = main.TRUE
@@ -1009,30 +995,6 @@
             str( numClusters ) +
             " SCCs" )
 
-        # paths
-        consistentPathsResult = main.TRUE
-        for controller in range( len( paths ) ):
-            controllerStr = str( controller + 1 )
-            if "Error" not in paths[ controller ]:
-                if paths[ controller ] == paths[ 0 ]:
-                    continue
-                else:  # paths not consistent
-                    main.log.report( "paths from ONOS" + controllerStr +
-                                     " is inconsistent with ONOS1" )
-                    consistentPathsResult = main.FALSE
-
-            else:
-                main.log.report( "Error in getting paths from ONOS" +
-                                 controllerStr )
-                consistentPathsResult = main.FALSE
-                main.log.warn( "ONOS" + controllerStr + " paths response: " +
-                               repr( paths[ controller ] ) )
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=consistentPathsResult,
-            onpass="Paths count is consistent across all ONOS nodes",
-            onfail="ONOS nodes have different counts of paths" )
-
         main.step( "Comparing ONOS topology to MN" )
         devicesResults = main.TRUE
         portsResults = main.TRUE
@@ -1086,8 +1048,7 @@
             linksResults = linksResults and currentLinksResult
 
         topoResult = devicesResults and portsResults and linksResults\
-            and consistentHostsResult and consistentClustersResult\
-            and consistentPathsResult
+            and consistentHostsResult and consistentClustersResult
         utilities.assert_equals( expect=main.TRUE, actual=topoResult,
                                 onpass="Topology Check Test successful",
                                 onfail="Topology Check Test NOT successful" )
@@ -1483,13 +1444,21 @@
             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 ) ):
+                controllerStr = str( controller + 1 )
+                for host in hosts[ controller ]:
+                    host
+                    if host[ 'ips' ] == []:
+                        main.log.error(
+                            "DEBUG:Error with host ips on controller" +
+                            controllerStr + ": " + str( host ) )
             ports = []
             ports.append( main.ONOScli1.ports() )
             ports.append( main.ONOScli2.ports() )
@@ -1514,180 +1483,145 @@
             clusters.append( main.ONOScli5.clusters() )
             clusters.append( main.ONOScli6.clusters() )
             clusters.append( main.ONOScli7.clusters() )
-            paths = []
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli1.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli2.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli3.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli4.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli5.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli6.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
-            tempTopo = main.ONOSbench.getTopology( main.ONOScli7.topology() )
-            paths.append( tempTopo.get( 'paths', False ) )
 
             elapsed = time.time() - startTime
             cliTime = time.time() - cliStart
             print "CLI time: " + str( cliTime )
 
-            for controller in range( numControllers ):
-                controllerStr = str( controller + 1 )
-                if devices[ controller ] or "Error" not in devices[
-                        controller ]:
-                    currentDevicesResult = main.Mininet1.compareSwitches(
-                        MNTopo,
-                        json.loads(
-                            devices[ controller ] ) )
-                else:
-                    currentDevicesResult = main.FALSE
-                utilities.assert_equals( expect=main.TRUE,
-                                        actual=currentDevicesResult,
-                                        onpass="ONOS" + controllerStr +
-                                        " Switches view is correct",
-                                        onfail="ONOS" + controllerStr +
-                                        " Switches view is incorrect" )
+            try: 
+                for controller in range( numControllers ):
+                    controllerStr = str( controller + 1 )
+                    if devices[ controller ] or "Error" not in devices[
+                            controller ]:
+                        currentDevicesResult = main.Mininet1.compareSwitches(
+                            MNTopo,
+                            json.loads(
+                                devices[ controller ] ) )
+                    else:
+                        currentDevicesResult = main.FALSE
+                    utilities.assert_equals( expect=main.TRUE,
+                                            actual=currentDevicesResult,
+                                            onpass="ONOS" + controllerStr +
+                                            " Switches view is correct",
+                                            onfail="ONOS" + controllerStr +
+                                            " Switches view is incorrect" )
 
-                if ports[ controller ] or "Error" not in ports[ controller ]:
-                    currentPortsResult = main.Mininet1.comparePorts(
-                        MNTopo,
-                        json.loads(
-                            ports[ controller ] ) )
-                else:
-                    currentPortsResult = main.FALSE
-                utilities.assert_equals( expect=main.TRUE,
-                                        actual=currentPortsResult,
-                                        onpass="ONOS" + controllerStr +
-                                        " ports view is correct",
-                                        onfail="ONOS" + controllerStr +
-                                        " ports view is incorrect" )
+                    if ports[ controller ] or "Error" not in ports[ controller ]:
+                        currentPortsResult = main.Mininet1.comparePorts(
+                            MNTopo,
+                            json.loads(
+                                ports[ controller ] ) )
+                    else:
+                        currentPortsResult = main.FALSE
+                    utilities.assert_equals( expect=main.TRUE,
+                                            actual=currentPortsResult,
+                                            onpass="ONOS" + controllerStr +
+                                            " ports view is correct",
+                                            onfail="ONOS" + controllerStr +
+                                            " ports view is incorrect" )
 
-                if links[ controller ] or "Error" not in links[ controller ]:
-                    currentLinksResult = main.Mininet1.compareLinks(
-                        MNTopo,
-                        json.loads(
-                            links[ controller ] ) )
-                else:
-                    currentLinksResult = main.FALSE
-                utilities.assert_equals( expect=main.TRUE,
-                                        actual=currentLinksResult,
-                                        onpass="ONOS" + controllerStr +
-                                        " links view is correct",
-                                        onfail="ONOS" + controllerStr +
-                                        " links view is incorrect" )
-            devicesResults = devicesResults and currentDevicesResult
-            portsResults = portsResults and currentPortsResult
-            linksResults = linksResults and currentLinksResult
+                    if links[ controller ] or "Error" not in links[ controller ]:
+                        currentLinksResult = main.Mininet1.compareLinks(
+                            MNTopo,
+                            json.loads(
+                                links[ controller ] ) )
+                    else:
+                        currentLinksResult = main.FALSE
+                    utilities.assert_equals( expect=main.TRUE,
+                                            actual=currentLinksResult,
+                                            onpass="ONOS" + controllerStr +
+                                            " links view is correct",
+                                            onfail="ONOS" + controllerStr +
+                                            " links view is incorrect" )
+                devicesResults = devicesResults and currentDevicesResult
+                portsResults = portsResults and currentPortsResult
+                linksResults = linksResults and currentLinksResult
 
-            # Compare json objects for hosts, dataplane clusters and paths
+                # Compare json objects for hosts and dataplane clusters
 
-            # hosts
-            consistentHostsResult = main.TRUE
-            for controller in range( len( hosts ) ):
-                controllerStr = str( controller + 1 )
-                if "Error" not in hosts[ controller ]:
-                    if hosts[ controller ] == hosts[ 0 ]:
-                        continue
-                    else:  # hosts not consistent
-                        main.log.report( "hosts from ONOS" + controllerStr +
-                                         " is inconsistent with ONOS1" )
-                        main.log.warn( repr( hosts[ controller ] ) )
+                # hosts
+                consistentHostsResult = main.TRUE
+                for controller in range( len( hosts ) ):
+                    controllerStr = str( controller + 1 )
+                    if "Error" not in hosts[ controller ]:
+                        if hosts[ controller ] == hosts[ 0 ]:
+                            continue
+                        else:  # hosts not consistent
+                            main.log.report( "hosts from ONOS" + controllerStr +
+                                             " is inconsistent with ONOS1" )
+                            main.log.warn( repr( hosts[ controller ] ) )
+                            consistentHostsResult = main.FALSE
+
+                    else:
+                        main.log.report( "Error in getting ONOS hosts from ONOS" +
+                                         controllerStr )
                         consistentHostsResult = main.FALSE
+                        main.log.warn( "ONOS" + controllerStr +
+                                       " hosts response: " +
+                                       repr( hosts[ controller ] ) )
+                utilities.assert_equals(
+                    expect=main.TRUE,
+                    actual=consistentHostsResult,
+                    onpass="Hosts view is consistent across all ONOS nodes",
+                    onfail="ONOS nodes have different views of hosts" )
 
-                else:
-                    main.log.report( "Error in getting ONOS hosts from ONOS" +
-                                     controllerStr )
-                    consistentHostsResult = main.FALSE
-                    main.log.warn( "ONOS" + controllerStr +
-                                   " hosts response: " +
-                                   repr( hosts[ controller ] ) )
-            utilities.assert_equals(
-                expect=main.TRUE,
-                actual=consistentHostsResult,
-                onpass="Hosts view is consistent across all ONOS nodes",
-                onfail="ONOS nodes have different views of hosts" )
+                # Strongly connected clusters of devices
+                consistentClustersResult = main.TRUE
+                for controller in range( len( clusters ) ):
+                    controllerStr = str( controller + 1 )
+                    if "Error" not in clusters[ controller ]:
+                        if clusters[ controller ] == clusters[ 0 ]:
+                            continue
+                        else:  # clusters not consistent
+                            main.log.report( "clusters from ONOS" +
+                                             controllerStr +
+                                             " is inconsistent with ONOS1" )
+                            consistentClustersResult = main.FALSE
 
-            # Strongly connected clusters of devices
-            consistentClustersResult = main.TRUE
-            for controller in range( len( clusters ) ):
-                controllerStr = str( controller + 1 )
-                if "Error" not in clusters[ controller ]:
-                    if clusters[ controller ] == clusters[ 0 ]:
-                        continue
-                    else:  # clusters not consistent
-                        main.log.report( "clusters from ONOS" +
-                                         controllerStr +
-                                         " is inconsistent with ONOS1" )
+                    else:
+                        main.log.report( "Error in getting dataplane clusters " +
+                                         "from ONOS" + controllerStr )
                         consistentClustersResult = main.FALSE
+                        main.log.warn( "ONOS" + controllerStr +
+                                       " clusters response: " +
+                                       repr( clusters[ controller ] ) )
+                utilities.assert_equals(
+                    expect=main.TRUE,
+                    actual=consistentClustersResult,
+                    onpass="Clusters view is consistent across all ONOS nodes",
+                    onfail="ONOS nodes have different views of clusters" )
+                # there should always only be one cluster
+                numClusters = len( json.loads( clusters[ 0 ] ) )
+                utilities.assert_equals(
+                    expect=1,
+                    actual=numClusters,
+                    onpass="ONOS shows 1 SCC",
+                    onfail="ONOS shows " +
+                    str( numClusters ) +
+                    " SCCs" )
 
-                else:
-                    main.log.report( "Error in getting dataplane clusters " +
-                                     "from ONOS" + controllerStr )
-                    consistentClustersResult = main.FALSE
-                    main.log.warn( "ONOS" + controllerStr +
-                                   " clusters response: " +
-                                   repr( clusters[ controller ] ) )
-            utilities.assert_equals(
-                expect=main.TRUE,
-                actual=consistentClustersResult,
-                onpass="Clusters view is consistent across all ONOS nodes",
-                onfail="ONOS nodes have different views of clusters" )
-            # there should always only be one cluster
-            numClusters = len( json.loads( clusters[ 0 ] ) )
-            utilities.assert_equals(
-                expect=1,
-                actual=numClusters,
-                onpass="ONOS shows 1 SCC",
-                onfail="ONOS shows " +
-                str( numClusters ) +
-                " SCCs" )
+                topoResult = ( devicesResults and portsResults and linksResults
+                               and consistentHostsResult
+                               and consistentClustersResult )
 
-            # paths
-            consistentPathsResult = main.TRUE
-            for controller in range( len( paths ) ):
-                controllerStr = str( controller + 1 )
-                if "Error" not in paths[ controller ]:
-                    if paths[ controller ] == paths[ 0 ]:
-                        continue
-                    else:  # paths not consistent
-                        main.log.report( "paths from ONOS" + controllerStr +
-                                         " is inconsistent with ONOS1" )
-                        consistentPathsResult = main.FALSE
+                topoResult = topoResult and int( count <= 2 )
+                note = "note it takes about " + str( int( cliTime ) ) + \
+                    " 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=topoResult,
+                                        onpass="Topology Check Test successful",
+                                        onfail="Topology Check Test NOT successful" )
+                if topoResult == main.TRUE:
+                    main.log.report( "ONOS topology view matches Mininet topology" )
+            except:
+                main.log.info( self.name + " ::::::" )
+                main.log.error( traceback.print_exc() )
+                main.log.info( self.name + " ::::::" )
 
-                else:
-                    main.log.report( "Error in getting paths from ONOS" +
-                                     controllerStr )
-                    consistentPathsResult = main.FALSE
-                    main.log.warn( "ONOS" + controllerStr +
-                                   " paths response: " +
-                                   repr( paths[ controller ] ) )
-            utilities.assert_equals(
-                expect=main.TRUE,
-                actual=consistentPathsResult,
-                onpass="Paths count is consistent across all ONOS nodes",
-                onfail="ONOS nodes have different counts of paths" )
-
-            topoResult = ( devicesResults and portsResults and linksResults
-                           and consistentHostsResult
-                           and consistentClustersResult
-                           and consistentPathsResult )
-
-        topoResult = topoResult and int( count <= 2 )
-        note = "note it takes about " + str( int( cliTime ) ) + \
-            " 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=topoResult,
-                                onpass="Topology Check Test successful",
-                                onfail="Topology Check Test NOT successful" )
-        if topoResult == main.TRUE:
-            main.log.report( "ONOS topology view matches Mininet topology" )
 
     def CASE9( self, main ):
         """
diff --git a/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.params b/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.params
index 6699caf..7f5cf4e 100644
--- a/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.params
+++ b/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.params
@@ -4,6 +4,7 @@
     <cellName>HA</cellName>
     </ENV>
     <Git>False</Git>
+    <branch> master </branch>
     <num_controllers> 1 </num_controllers>
 
     <CTRL>
diff --git a/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.py b/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.py
index 2aea5bf..39ce920 100644
--- a/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.py
+++ b/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.py
@@ -49,7 +49,7 @@
         PULLCODE = False
         if main.params[ 'Git' ] == 'True':
             PULLCODE = True
-
+        gitBranch = main.params[ 'branch' ]
         cellName = main.params[ 'ENV' ][ 'cellName' ]
 
         # set global variables
@@ -108,17 +108,14 @@
         if PULLCODE:
             # TODO Configure branch in params
             main.step( "Git checkout and pull master" )
-            main.ONOSbench.gitCheckout( "master" )
+            main.ONOSbench.gitCheckout( gitBranch )
             gitPullResult = main.ONOSbench.gitPull()
 
             main.step( "Using mvn clean & install" )
-            cleanInstallResult = main.TRUE
-
-            if gitPullResult == main.TRUE:
-                cleanInstallResult = main.ONOSbench.cleanInstall()
-            else:
-                main.log.warn( "Did not pull new code so skipping mvn " +
-                               "clean install" )
+            cleanInstallResult = main.ONOSbench.cleanInstall()
+        else:
+            main.log.warn( "Did not pull new code so skipping mvn " +
+                           "clean install" )
         main.ONOSbench.getVersion( report=True )
 
         cellResult = main.ONOSbench.setCell( "SingleHA" )
@@ -197,7 +194,6 @@
     def CASE3( self, main ):
         """
         Assign intents
-
         """
         # FIXME: we must reinstall intents until we have a persistant
         # datastore!
@@ -216,6 +212,11 @@
         pingResult = main.FALSE
         time1 = time.time()
         pingResult = main.Mininet1.pingall()
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=pingResult,
+            onpass="Reactive Pingall test passed",
+            onfail="Reactive Pingall failed, one or more ping pairs failed" )
         time2 = time.time()
         main.log.info( "Time for pingall: %2f seconds" % ( time2 - time1 ) )
 
@@ -247,11 +248,12 @@
                 tmpResult = main.FALSE
             intentAddResult = bool( pingResult and intentAddResult
                                      and tmpResult )
+            # TODO Check that intents were added?
         utilities.assert_equals(
             expect=True,
             actual=intentAddResult,
-            onpass="Switch mastership correctly assigned",
-            onfail="Error in ( re )assigning switch mastership" )
+            onpass="Pushed host intents to ONOS",
+            onfail="Error in pushing host intents to ONOS" )
         # TODO Check if intents all exist in datastore
 
     def CASE4( self, main ):
@@ -275,6 +277,12 @@
         if PingResult == main.FALSE:
             main.log.report(
                 "Intents have not been installed correctly, pings failed." )
+            #TODO: pretty print
+            main.log.warn( "ONSO1 intents: " )
+            main.log.warn( json.dumps( json.loads( main.ONOScli1.intents() ),
+                                       sort_keys=True,
+                                       indent=4,
+                                       separators=( ',', ': ' ) ) )
         if PingResult == main.TRUE:
             main.log.report(
                 "Intents have been installed correctly and verified by pings" )
diff --git a/TestON/tests/LincOETest/LincOETest.py b/TestON/tests/LincOETest/LincOETest.py
index 6c59c5b..b693138 100644
--- a/TestON/tests/LincOETest/LincOETest.py
+++ b/TestON/tests/LincOETest/LincOETest.py
@@ -29,62 +29,62 @@
         """
         import time
 
-        cell_name = main.params[ 'ENV' ][ 'cellName' ]
+        cellName = main.params[ 'ENV' ][ 'cellName' ]
 
-        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
-        ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+        ONOS1Port = main.params[ 'CTRL' ][ 'port1' ]
 
-        git_pull_trigger = main.params[ 'GIT' ][ 'autoPull' ]
-        git_checkout_branch = main.params[ 'GIT' ][ 'checkout' ]
+        gitPullTrigger = main.params[ 'GIT' ][ 'autoPull' ]
+        gitCheckoutBranch = 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", cell_name, "10.128.10.90",
+        cellFileResult = main.ONOSbench.createCellFile(
+            "10.128.20.10", cellName, "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()
+        # cellResult = main.ONOSbench.setCell( cellName )
+        cellResult = main.ONOSbench.setCell( "temp_cell_2" )
+        verifyResult = main.ONOSbench.verifyCell()
 
-        if git_pull_trigger == 'on':
+        if gitPullTrigger == 'on':
             main.step( "Git checkout and pull master" )
-            main.ONOSbench.git_checkout( git_checkout_branch )
-            git_pull_result = main.ONOSbench.git_pull()
+            main.ONOSbench.gitCheckout( gitCheckoutBranch )
+            gitPullResult = main.ONOSbench.gitPull()
         else:
             main.log.info( "Git checkout and pull skipped by config" )
-            git_pull_result = main.TRUE
+            gitPullResult = main.TRUE
 
         main.step( "Using mvn clean & install" )
-        #clean_install_result = main.ONOSbench.clean_install()
-        clean_install_result = main.TRUE
+        # cleanInstallResult = main.ONOSbench.cleanInstall()
+        cleanInstallResult = main.TRUE
 
         main.step( "Creating ONOS package" )
-        package_result = main.ONOSbench.onos_package()
+        packageResult = main.ONOSbench.onosPackage()
 
         main.step( "Installing ONOS package" )
-        onos_install_result = main.ONOSbench.onos_install()
-        onos1_isup = main.ONOSbench.isup()
+        onosInstallResult = main.ONOSbench.onosInstall()
+        onos1Isup = main.ONOSbench.isup()
 
         main.step( "Starting ONOS service" )
-        start_result = main.ONOSbench.onos_start( ONOS1_ip )
+        startResult = main.ONOSbench.onosStart( ONOS1Ip )
 
         main.step( "Setting cell for ONOScli" )
-        main.ONOScli.set_cell( cell_name )
+        main.ONOScli.setCell( cellName )
 
         main.step( "Starting ONOScli" )
-        main.ONOScli.start_onos_cli( ONOS1_ip )
+        main.ONOScli.startOnosCli( ONOS1Ip )
 
-        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" )
+        case1Result = ( cleanInstallResult and packageResult and
+                        cellResult and verifyResult and onosInstallResult and
+                        onos1Isup and startResult )
+        utilities.assertEquals( expect=main.TRUE, actual=case1Result,
+                                onpass="Test startup successful",
+                                onfail="Test startup NOT successful" )
 
         time.sleep( 10 )
 
@@ -94,18 +94,18 @@
         """
         import time
 
-        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
-        default_sw_port = main.params[ 'CTRL' ][ 'port1' ]
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+        defaultSwPort = main.params[ 'CTRL' ][ 'port1' ]
 
         # Assign packet level switches to controller
-        main.Mininet1.assign_sw_controller(
+        main.Mininet1.assignSwController(
             sw="1",
-            ip1=ONOS1_ip,
-            port1=default_sw_port )
-        main.Mininet1.assign_sw_controller(
+            ip1=ONOS1Ip,
+            port1=defaultSwPort )
+        main.Mininet1.assignSwController(
             sw="2",
-            ip1=ONOS1_ip,
-            port1=default_sw_port )
+            ip1=ONOS1Ip,
+            port1=defaultSwPort )
 
         # Check devices in controller
         # This should include Linc-OE devices as well
diff --git a/TestON/tests/MultiProd/MultiProd.bak b/TestON/tests/MultiProd/MultiProd.bak
new file mode 100755
index 0000000..11af10b
--- /dev/null
+++ b/TestON/tests/MultiProd/MultiProd.bak
@@ -0,0 +1,1156 @@
+
+#Testing the basic functionality of ONOS Next
+#For sanity and driver functionality excercises only.
+
+import time
+import time
+import json
+
+time.sleep(1)
+class MultiProd:
+    def __init__(self):
+        self.default = ''
+
+    def CASE1(self, main):
+        '''
+        Startup sequence:
+        cell <name>
+        onos-verify-cell
+        onos-remove-raft-logs        
+        git pull
+        mvn clean install
+        onos-package
+        onos-install -f
+        onos-wait-for-start
+        '''
+        
+        cell_name = main.params['ENV']['cellName']
+        ONOS1_ip = main.params['CTRL']['ip1']
+        ONOS2_ip = main.params['CTRL']['ip2']
+        ONOS3_ip = main.params['CTRL']['ip3']    
+       
+        main.case("Setting up test environment")
+        main.log.report("This testcase is testing setting up test environment") 
+        main.log.report("__________________________________")
+ 
+        main.step("Applying cell variable to environment")
+        cell_result1 = main.ONOSbench.set_cell(cell_name)
+        #cell_result2 = main.ONOScli1.set_cell(cell_name)
+        #cell_result3 = main.ONOScli2.set_cell(cell_name)
+        #cell_result4 = main.ONOScli3.set_cell(cell_name)
+        verify_result = main.ONOSbench.verify_cell() 
+        cell_result = cell_result1
+
+        main.step("Removing raft logs before a clen installation of ONOS")
+        remove_log_Result = main.ONOSbench.onos_remove_raft_logs()        
+
+        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
+        main.ONOSbench.get_version(report=True)
+
+        if git_pull_result == 1:
+            main.step("Using mvn clean & install")
+            main.ONOSbench.clean_install()
+
+        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")
+        onos1_install_result = main.ONOSbench.onos_install(options="-f", node=ONOS1_ip)
+        onos2_install_result = main.ONOSbench.onos_install(options="-f", node=ONOS2_ip)
+        onos3_install_result = main.ONOSbench.onos_install(options="-f", node=ONOS3_ip)
+        onos_install_result = onos1_install_result and onos2_install_result and onos3_install_result        
+        if onos_install_result == main.TRUE:
+            main.log.report("Installing ONOS package successful")
+        else:
+            main.log.report("Installing ONOS package failed")
+        	
+        onos1_isup = main.ONOSbench.isup(ONOS1_ip)
+        onos2_isup = main.ONOSbench.isup(ONOS2_ip)
+        onos3_isup = main.ONOSbench.isup(ONOS3_ip)
+        onos_isup = onos1_isup and onos2_isup and onos3_isup
+        if onos_isup == main.TRUE:
+            main.log.report("ONOS instances are up and ready")
+        else:
+            main.log.report("ONOS instances may not be up")          
+
+        main.step("Starting ONOS service")
+        start_result = main.TRUE
+        #start_result = main.ONOSbench.onos_start(ONOS1_ip)
+        startcli1 = main.ONOScli1.start_onos_cli(ONOS_ip = ONOS1_ip)
+        startcli2 = main.ONOScli2.start_onos_cli(ONOS_ip = ONOS2_ip)
+        startcli3 = main.ONOScli3.start_onos_cli(ONOS_ip = ONOS3_ip)
+        print startcli1
+        print startcli2
+        print startcli3
+            
+        case1_result = (package_result and\
+                cell_result and verify_result and onos_install_result and\
+                onos_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']
+        ONOS2_ip = main.params['CTRL']['ip2']
+        ONOS3_ip = main.params['CTRL']['ip3']
+	
+        main.case("Cleaning up test environment")
+
+        main.step("Testing ONOS kill function")
+        kill_result1 = main.ONOSbench.onos_kill(ONOS1_ip)
+        kill_result2 = main.ONOSbench.onos_kill(ONOS2_ip)
+        kill_result3 = main.ONOSbench.onos_kill(ONOS3_ip)
+	
+        main.step("Stopping ONOS service")
+        stop_result1 = main.ONOSbench.onos_stop(ONOS1_ip)
+        stop_result2 = main.ONOSbench.onos_stop(ONOS2_ip)
+        stop_result3 = main.ONOSbench.onos_stop(ONOS3_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']
+        ONOS2_ip = main.params['CTRL']['ip2']
+        ONOS3_ip = main.params['CTRL']['ip3']	
+
+        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)
+        cmd_result2 = main.ONOSbench.onos_cli(ONOS2_ip, cmdstr1)
+        main.log.info("onos command returned: "+cmd_result2)
+        cmd_result3 = main.ONOSbench.onos_cli(ONOS3_ip, cmdstr1)
+        main.log.info("onos command returned: "+cmd_result3)
+
+        main.step("Sending command 'onos -w <onos-ip> onos:topology'")
+        cmdstr2 = "onos:topology"
+        cmd_result4 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr2)
+        main.log.info("onos command returned: "+cmd_result4)
+        cmd_result5 = main.ONOSbench.onos_cli(ONOS2_ip, cmdstr2)
+        main.log.info("onos command returned: "+cmd_result5)
+        cmd_result6 = main.ONOSbench.onos_cli(ONOS6_ip, cmdstr2)
+        main.log.info("onos command returned: "+cmd_result6)
+
+
+    def CASE4(self, main):
+        import re
+        import time
+        ONOS1_ip = main.params['CTRL']['ip1']
+        ONOS2_ip = main.params['CTRL']['ip2']
+        ONOS3_ip = main.params['CTRL']['ip3']
+        ONOS1_port = main.params['CTRL']['port1']
+        ONOS2_port = main.params['CTRL']['port2']
+        ONOS3_port = main.params['CTRL']['port3']
+        
+        main.log.report("This testcase is testing the assignment of all the switches to all controllers and discovering the hosts in reactive mode")
+        main.log.report("__________________________________")        
+        main.case("Pingall Test(No intents are added)")
+        main.step("Assigning switches to controllers")
+        for i in range(1,29): #1 to (num of switches +1)
+            main.Mininet1.assign_sw_controller(sw=str(i),count=3, 
+                    ip1=ONOS1_ip, port1=ONOS1_port,
+                    ip2=ONOS2_ip, port2=ONOS2_port,
+		            ip3=ONOS3_ip, port3=ONOS3_port)
+
+        switch_mastership = main.TRUE
+        for i in range (1,29):
+            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")
+        #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
+        if ping_result == main.TRUE:
+            main.log.report("Pingall Test in reactive mode to discover the hosts successful")
+        else:
+            main.log.report("Pingall Test in reactive mode to discover the hosts failed")
+
+        utilities.assert_equals(expect=main.TRUE, actual=case4_result,onpass="Controller assignment and Pingall Test successful",onfail="Controller assignment and 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
+        ONOS1_ip = main.params['CTRL']['ip1']
+        ONOS2_ip = main.params['CTRL']['ip2']
+        ONOS3_ip = main.params['CTRL']['ip3']
+        
+        main.log.report("This testcase is testing if all ONOS nodes are in topology sync with mininet and its peer ONOS nodes")
+        main.log.report("__________________________________")        
+        main.case ("Testing Mininet topology with the topology of multi instances ONOS") 
+        main.step("Collecting topology information from ONOS")
+        devices1 = main.ONOScli1.devices()
+        devices2 = main.ONOScli2.devices()
+        devices3 = main.ONOScli3.devices()
+        #print "devices1 = ", devices1
+        #print "devices2 = ", devices2
+        #print "devices3 = ", devices3
+        hosts1 = main.ONOScli1.hosts()
+        hosts2 = main.ONOScli2.hosts()
+        hosts3 = main.ONOScli3.hosts()
+        #print "hosts1 = ", hosts1
+        #print "hosts2 = ", hosts2
+        #print "hosts3 = ", hosts3
+        ports1 = main.ONOScli1.ports()
+        ports2 = main.ONOScli2.ports()
+        ports3 = main.ONOScli3.ports()
+        #print "ports1 = ", ports1
+        #print "ports2 = ", ports2    
+        #print "ports3 = ", ports3
+        links1 = main.ONOScli1.links()
+        links2 = main.ONOScli2.links()
+        links3 = main.ONOScli3.links()
+        #print "links1 = ", links1
+        #print "links2 = ", links2
+        #print "links3 = ", links3
+        
+        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")
+        
+        switches_results1 =  main.Mininet1.compare_switches(MNTopo, json.loads(devices1))
+        print "switches_Result1 = ", switches_results1
+        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")
+    
+        switches_results3 =  main.Mininet1.compare_switches(MNTopo, json.loads(devices3))
+        utilities.assert_equals(expect=main.TRUE, actual=switches_results3,
+                onpass="ONOS3 Switches view is correct",
+                onfail="ONOS3 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")
+
+        ports_results3 =  main.Mininet1.compare_ports(MNTopo, json.loads(ports3))
+        utilities.assert_equals(expect=main.TRUE, actual=ports_results3,
+                onpass="ONOS3 Ports view is correct",
+                onfail="ONOS3 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")
+
+        links_results3 =  main.Mininet1.compare_links(MNTopo, json.loads(links3))
+        utilities.assert_equals(expect=main.TRUE, actual=links_results3,
+                onpass="ONOS2 Links view is correct",
+                onfail="ONOS2 Links view is incorrect")
+
+        #topo_result = switches_results1 and switches_results2 and switches_results3\
+                #and ports_results1 and ports_results2 and ports_results3\
+                #and links_results1 and links_results2 and links_results3
+        
+        topo_result = switches_results1 and switches_results2 and switches_results3\
+                and links_results1 and links_results2 and links_results3
+
+        if topo_result == main.TRUE:
+            main.log.report("Topology Check Test with mininet and ONOS instances successful")
+        else:
+            main.log.report("Topology Check Test with mininet and ONOS instances failed")
+
+        utilities.assert_equals(expect=main.TRUE, actual=topo_result,
+                onpass="Topology Check Test successful",
+                onfail="Topology Check Test NOT successful")
+
+
+
+
+    def CASE10(self):
+        main.log.report("This testcase uninstalls the reactive forwarding app")
+        main.log.report("__________________________________")
+        main.case("Uninstalling reactive forwarding app")
+        #Unistall onos-app-fwd app to disable reactive forwarding
+        appUninstall_result1 = main.ONOScli1.feature_uninstall("onos-app-fwd")
+        appUninstall_result2 = main.ONOScli2.feature_uninstall("onos-app-fwd")
+        appUninstall_result3 = main.ONOScli3.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)
+        
+        hosts = main.ONOScli1.hosts()
+        main.log.info(hosts)
+        
+        case10_result = appUninstall_result1 and appUninstall_result2 and appUninstall_result3
+        utilities.assert_equals(expect=main.TRUE, actual=case10_result,onpass="Reactive forwarding app uninstallation successful",onfail="Reactive forwarding app uninstallation failed")
+
+
+    def CASE6(self):
+        main.log.report("This testcase is testing the addition of host intents and then doing pingall")
+        main.log.report("__________________________________")        
+        main.case("Obtaining hostsfor adding host intents")
+        main.step("Get hosts")
+        hosts = main.ONOScli1.hosts()
+        main.log.info(hosts)
+
+        main.step("Get all devices id")
+        devices_id_list = main.ONOScli1.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 intents for mn hosts(h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,h15-h25,h16-h26,h17-h27)")
+        hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1")
+        hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1")
+        hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1")
+        hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1")
+        hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1")
+        hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1")
+        hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1")
+        hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1")
+        hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1")
+        hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1") 
+        '''
+
+        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 )
+
+        flowHandle = main.ONOScli1.flows()
+        #print "flowHandle = ", flowHandle
+        main.log.info("flows:" +flowHandle)
+
+        count = 1
+        i = 8
+        Ping_Result = main.TRUE
+        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 between h" + str(i) + " and h" + str(i+10) +"have failed")
+                i=19
+                Ping_Result = main.FALSE
+            elif ping==main.TRUE:
+                main.log.info("Ping test between h" + str(i) + " and h" + str(i+10) + "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("Host intents have not ben installed correctly. Cleaning up")
+            #main.cleanup()
+            #main.exit()
+        if Ping_Result==main.TRUE:
+            main.log.report("Host intents have been installed correctly")
+
+        case6_result = Ping_Result
+        utilities.assert_equals(expect=main.TRUE, actual=case6_result,
+                onpass="Host intent addition and Pingall Test successful",
+                onfail="Host intent addition and Pingall Test NOT successful")
+
+
+    def CASE7 (self,main):
+       
+        ONOS1_ip = main.params['CTRL']['ip1']
+
+        link_sleep = int(main.params['timers']['LinkDiscovery'])
+
+        main.log.report("This testscase is killing a link to ensure that link discovery is consistent")
+        main.log.report("__________________________________")        
+        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.ONOScli1.topology()
+        topology_result = main.ONOSbench.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.ONOScli2.topology()
+        Link_Down = main.ONOSbench.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.ONOScli2.topology()
+        Link_Up = main.ONOSbench.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")
+        main.case ("Testing Mininet topology with the topology of multi instances ONOS") 
+        main.step("Collecting topology information from ONOS")
+        devices1 = main.ONOScli1.devices()
+        devices2 = main.ONOScli2.devices()
+        devices3 = main.ONOScli3.devices()
+        print "devices1 = ", devices1
+        print "devices2 = ", devices2
+        print "devices3 = ", devices3
+        hosts1 = main.ONOScli1.hosts()
+        hosts2 = main.ONOScli2.hosts()
+        hosts3 = main.ONOScli3.hosts()
+        #print "hosts1 = ", hosts1
+        #print "hosts2 = ", hosts2
+        #print "hosts3 = ", hosts3
+        ports1 = main.ONOScli1.ports()
+        ports2 = main.ONOScli2.ports()
+        ports3 = main.ONOScli3.ports()
+        #print "ports1 = ", ports1
+        #print "ports2 = ", ports2    
+        #print "ports3 = ", ports3
+        links1 = main.ONOScli1.links()
+        links2 = main.ONOScli2.links()
+        links3 = main.ONOScli3.links()
+        #print "links1 = ", links1
+        #print "links2 = ", links2
+        #print "links3 = ", links3
+        
+        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")
+        
+        switches_results1 =  main.Mininet1.compare_switches(MNTopo, json.loads(devices1))
+        print "switches_Result1 = ", switches_results1
+        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")
+    
+        switches_results3 =  main.Mininet1.compare_switches(MNTopo, json.loads(devices3))
+        utilities.assert_equals(expect=main.TRUE, actual=switches_results3,
+                onpass="ONOS3 Switches view is correct",
+                onfail="ONOS3 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")
+
+        ports_results3 =  main.Mininet1.compare_ports(MNTopo, json.loads(ports3))
+        utilities.assert_equals(expect=main.TRUE, actual=ports_results3,
+                onpass="ONOS3 Ports view is correct",
+                onfail="ONOS3 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")
+
+        links_results3 =  main.Mininet1.compare_links(MNTopo, json.loads(links3))
+        utilities.assert_equals(expect=main.TRUE, actual=links_results3,
+                onpass="ONOS2 Links view is correct",
+                onfail="ONOS2 Links view is incorrect")
+               
+        #topo_result = switches_results1 and switches_results2 and switches_results3\
+                #and ports_results1 and ports_results2 and ports_results3\
+                #and links_results1 and links_results2 and links_results3
+        
+        topo_result = switches_results1 and switches_results2 and switches_results3\
+                and links_results1 and links_results2 and links_results3
+
+        utilities.assert_equals(expect=main.TRUE, actual=topo_result and Link_Up and Link_Down,
+                onpass="Topology Check Test successful",
+                onfail="Topology Check Test NOT successful")
+
+
+    def CASE8(self):
+        '''
+        Intent removal
+        ''' 
+        main.log.report("This testcase removes host any previously added intents")
+        main.log.report("__________________________________")        
+        main.log.info("Removing any previously installed intents")
+        main.case("Removing intents")
+        main.step("Obtain the intent id's")
+        intent_result = main.ONOScli1.intents(json_format = False)
+        
+        intent_linewise = intent_result.split("\n")
+        intentList = []
+        for line in intent_linewise:
+            if line.startswith("id="):
+                intentList.append(line)
+
+        intentids = []
+        for line in intentList:
+            intentids.append(line.split(",")[0].split("=")[1])
+        for id in intentids:
+            main.log.info("id = " +id)
+
+        main.step("Iterate through the intentids list and remove each intent")
+        for id in intentids:
+            main.ONOScli1.remove_intent(intent_id = id)
+
+        intent_result = main.ONOScli1.intents(json_format = False)
+        main.log.info("intent_result = " +intent_result)
+        case8_result = main.TRUE
+        
+        i = 8
+        Ping_Result = main.TRUE
+        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.TRUE:
+                i = 19
+                Ping_Result = main.TRUE
+            elif ping==main.FALSE:
+                i+=1
+                Ping_Result = main.FALSE
+            else:
+                main.log.info("Unknown error")
+                Ping_Result = main.ERROR
+        
+        #Note: If the ping result failed, that means the intents have been withdrawn correctly.
+        if Ping_Result==main.TRUE:
+            main.log.report("Host intents have not been withdrawn correctly")
+            #main.cleanup()
+            #main.exit()
+        if Ping_Result==main.FALSE:
+            main.log.report("Host intents have been withdrawn correctly")
+
+        case8_result = case8_result and Ping_Result
+
+        if case8_result == main.FALSE:
+            main.log.report("Intent removal successful")
+        else:
+            main.log.report("Intent removal failed")
+                        
+        utilities.assert_equals(expect=main.FALSE, actual=case8_result,
+                onpass="Intent removal test failed",
+                onfail="Intent removal test successful")
+             
+
+    def CASE9(self):
+        '''
+        This test case adds point intents. Make sure you run test case 8 which is host intent removal before executing this test case.
+        Else the host intent's flows will persist on switches and the pings would work even if there is some issue with the point intent's flows
+        '''
+        main.log.report("This testcase adds point intents and then does pingall")
+        main.log.report("__________________________________")        
+        main.log.info("Adding point intents")
+        main.case("Adding bidirectional point for mn hosts(h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,h15-h25,h16-h26,h17-h27)") 
+        main.step("Add point-to-point intents for mininet hosts h8 and h18 or ONOS hosts h8 and h12")
+        ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003008/1", "of:0000000000006018/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info("Point to point intent install successful")
+            #main.log.info(get_intent_result)
+       
+        ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006018/1", "of:0000000000003008/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent("of:0000000000003009/1", "of:0000000000006019/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info("Point to point intent install successful")
+            #main.log.info(get_intent_result)
+       
+        ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006019/1", "of:0000000000003009/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent("of:0000000000003010/1", "of:0000000000006020/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info("Point to point intent install successful")
+            #main.log.info(get_intent_result)
+       
+        ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006020/1", "of:0000000000003010/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent("of:0000000000003011/1", "of:0000000000006021/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info("Point to point intent install successful")
+            #main.log.info(get_intent_result)
+       
+        ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006021/1", "of:0000000000003011/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent("of:0000000000003012/1", "of:0000000000006022/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info("Point to point intent install successful")
+            #main.log.info(get_intent_result)
+       
+        ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006022/1", "of:0000000000003012/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent("of:0000000000003013/1", "of:0000000000006023/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info("Point to point intent install successful")
+            #main.log.info(get_intent_result)
+       
+        ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006023/1", "of:0000000000003013/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent("of:0000000000003014/1", "of:0000000000006024/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info("Point to point intent install successful")
+            #main.log.info(get_intent_result)
+       
+        ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006024/1", "of:0000000000003014/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent("of:0000000000003015/1", "of:0000000000006025/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info("Point to point intent install successful")
+            #main.log.info(get_intent_result)
+       
+        ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006025/1", "of:0000000000003015/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent("of:0000000000003016/1", "of:0000000000006026/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info("Point to point intent install successful")
+            #main.log.info(get_intent_result)
+       
+        ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006026/1", "of:0000000000003016/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent("of:0000000000003017/1", "of:0000000000006027/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info("Point to point intent install successful")
+            #main.log.info(get_intent_result)
+       
+        ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006027/1", "of:0000000000003017/1")
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info("Point to point intent install successful")
+            #main.log.info(get_intent_result)
+
+        print("_______________________________________________________________________________________")
+
+        flowHandle = main.ONOScli1.flows()
+        #print "flowHandle = ", flowHandle
+        main.log.info("flows :" + flowHandle)        
+
+        count = 1
+        i = 8
+        Ping_Result = main.TRUE
+        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 between h" + str(i) + " and h" + str(i+10) +"have failed")
+                i=19
+                Ping_Result = main.FALSE
+            elif ping==main.TRUE:
+                main.log.info("Ping test between h" + str(i) + " and h" + str(i+10) + "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("Ping all test after Point intents addition failed. Cleaning up")
+            #main.cleanup()
+            #main.exit()
+        if Ping_Result==main.TRUE:
+            main.log.report("Ping all test after Point intents addition successful")
+
+        case8_result = Ping_Result
+        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 CASE31(self):
+        ''' 
+            This test case adds point intent related to SDN-IP matching on ICMP (ethertype=IPV4, ipProto=1)
+        '''
+        import json
+
+        main.log.report("This test case adds point intent related to SDN-IP matching on ICMP")
+        main.case("Adding bidirectional point intent related to SDN-IP matching on ICMP")
+        main.step("Adding bidirectional point intent")
+        #add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32 --ethType=IPV4 --ipProto=1  of:0000000000003008/1 of:0000000000006018/1
+        
+        hosts_json = json.loads(main.ONOScli1.hosts())
+        for  i in range(8,11):
+            main.log.info("Adding point 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()
+            host1_id = main.ONOScli1.get_host(host1)['id']
+            host2_id = main.ONOScli1.get_host(host2)['id']
+            for host in hosts_json:
+                if host['id'] == host1_id:
+                    ip1 = host['ips'][0]
+                    ip1 = str(ip1+"/32")
+                    device1 = host['location']['device']
+                    device1 = str(device1+"/1")
+                elif host['id'] == host2_id:
+                    ip2 = str(host['ips'][0])+"/32"
+                    device2 = host['location']["device"]
+                    device2 = str(device2+"/1")
+                
+            p_intent_result1 = main.ONOScli1.add_point_intent(ingress_device=device1, egress_device=device2, ipSrc=ip1, ipDst=ip2,
+                                  ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['icmpProto'])
+            
+            get_intent_result = main.ONOScli1.intents(json_format = False)
+            main.log.info(get_intent_result)
+ 
+            p_intent_result2 = main.ONOScli1.add_point_intent(ingress_device=device2, egress_device=device1, ipSrc=ip2, ipDst=ip1, 
+                                  ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['icmpProto']) 
+            
+            get_intent_result = main.ONOScli1.intents(json_format = False)
+            main.log.info(get_intent_result)
+            if (p_intent_result1 and p_intent_result2) == main.TRUE:
+                #get_intent_result = main.ONOScli1.intents()
+                #main.log.info(get_intent_result)
+                main.log.info("Point intent related to SDN-IP matching on ICMP install successful")
+       
+        time.sleep(15) 
+        get_intent_result = main.ONOScli1.intents(json_format = False)
+        main.log.info("intents = "+ get_intent_result)
+        get_flows_result = main.ONOScli1.flows()
+        main.log.info("flows = " + get_flows_result)
+        
+        count = 1
+        i = 8
+        Ping_Result = main.TRUE
+        while i <11 :
+            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 <3:
+                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 between h" + str(i) + " and h" + str(i+10) +"have failed")
+                i=19
+                Ping_Result = main.FALSE
+            elif ping==main.TRUE:
+                main.log.info("Ping test between h" + str(i) + " and h" + str(i+10) + "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("Ping test after Point intents related to SDN-IP matching on ICMP failed.")
+            #main.cleanup()
+            #main.exit()
+        if Ping_Result==main.TRUE:
+            main.log.report("Ping all test after Point intents related to SDN-IP matching on ICMP successful")
+                   
+        case31_result = Ping_Result and p_intent_result1 and p_intent_result2
+        utilities.assert_equals(expect=main.TRUE, actual=case31_result,
+                onpass="Point intent related to SDN-IP matching on ICMP and ping test successful",
+                onfail="Point intent related to SDN-IP matching on ICMP and ping test failed")
+   
+    def CASE32(self):
+        ''' 
+            This test case adds point intent related to SDN-IP matching on TCP (ethertype=IPV4, ipProto=6, DefaultPort for iperf=5001)
+            Note: Although BGP port is 179, we are using 5001 because iperf is used for verifying and iperf's default port is 5001
+        '''
+        import json
+
+        main.log.report("This test case adds point intent related to SDN-IP matching on TCP")
+        main.case("Adding bidirectional point intent related to SDN-IP matching on TCP")
+        main.step("Adding bidirectional point intent")
+        """
+        add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32 --ethType=IPV4 --ipProto=6 --tcpDst=5001  of:0000000000003008/1 of:0000000000006018/1
+
+        add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32 --ethType=IPV4 --ipProto=6 --tcpDst=5001  of:0000000000006018/1 of:0000000000003008/1
+    
+        add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32 --ethType=IPV4 --ipProto=6 --tcpSrc=5001  of:0000000000003008/1 of:0000000000006018/1
+
+        add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32 --ethType=IPV4 --ipProto=6 --tcpSrc=5001  of:0000000000006018/1 of:0000000000003008/1
+
+        """           
+    
+        hosts_json = json.loads(main.ONOScli1.hosts())
+        for  i in range(8,9):
+            main.log.info("Adding point 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()
+            host1_id = main.ONOScli1.get_host(host1)['id']
+            host2_id = main.ONOScli1.get_host(host2)['id']
+            for host in hosts_json:
+                if host['id'] == host1_id:
+                    ip1 = host['ips'][0]
+                    ip1 = str(ip1+"/32")
+                    device1 = host['location']['device']
+                    device1 = str(device1+"/1")
+                elif host['id'] == host2_id:
+                    ip2 = str(host['ips'][0])+"/32"
+                    device2 = host['location']["device"]
+                    device2 = str(device2+"/1")
+                
+            p_intent_result1 = main.ONOScli1.add_point_intent(ingress_device=device1, egress_device=device2, ipSrc=ip1, ipDst=ip2,
+                                  ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['tcpProto'], tcpDst=main.params['SDNIP']['dstPort']) 
+            p_intent_result2 = main.ONOScli1.add_point_intent(ingress_device=device2, egress_device=device1, ipSrc=ip2, ipDst=ip1, 
+                                  ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['tcpProto'], tcpDst=main.params['SDNIP']['dstPort'])
+
+            p_intent_result3 = main.ONOScli1.add_point_intent(ingress_device=device1, egress_device=device2, ipSrc=ip1, ipDst=ip2,
+                                  ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['tcpProto'], tcpSrc=main.params['SDNIP']['srcPort'])
+            p_intent_result4 = main.ONOScli1.add_point_intent(ingress_device=device2, egress_device=device1, ipSrc=ip2, ipDst=ip1,
+                                  ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['tcpProto'], tcpSrc=main.params['SDNIP']['srcPort']) 
+
+            p_intent_result = p_intent_result1 and p_intent_result2 and p_intent_result3 and p_intent_result4
+            if p_intent_result ==main.TRUE:
+                get_intent_result = main.ONOScli1.intents(json_format = False)
+                main.log.info(get_intent_result)
+                main.log.info("Point intent related to SDN-IP matching on TCP install successful")
+        
+        iperf_result = main.Mininet1.iperf('h8', 'h18') 
+        if iperf_result == main.TRUE:
+            main.log.report("iperf test successful")
+        else:
+            main.log.report("iperf test failed")
+
+
+        case32_result = p_intent_result and iperf_result
+        utilities.assert_equals(expect=main.TRUE, actual=case32_result,
+                onpass="Ping all test after Point intents addition related to SDN-IP on TCP match successful",
+                onfail="Ping all test after Point intents addition related to SDN-IP on TCP match failed")
+
+
+    def CASE33(self):
+        ''' 
+            This test case adds multipoint to singlepoint  intent related to SDN-IP matching on destination ip and the action is to rewrite the mac address 
+            Here the mac address to be rewritten is the mac address of the egress device
+        '''
+        import json
+        import time
+
+        main.log.report("This test case adds multipoint to singlepoint intent related to SDN-IP matching on destination ip and rewrite mac address action")
+        main.case("Adding multipoint to singlepoint intent related to SDN-IP matching on destination ip")
+        main.step("Adding bidirectional multipoint to singlepoint intent")
+        """
+        add-multi-to-single-intent --ipDst=10.0.3.0/24 --setEthDst=00:00:00:00:00:12 of:0000000000003008/1 0000000000003009/1 of:0000000000006018/1
+        
+        add-multi-to-single-intent --ipDst=10.0.1.0/24 --setEthDst=00:00:00:00:00:08 of:0000000000006018/1 0000000000003009/1 of:0000000000003008/1 
+        """    
+        
+        main.case("Installing multipoint to single point intent with rewrite mac address")
+        main.step("Uninstalling proxy arp app")
+        #Unistall onos-app-proxyarp app to disable reactive forwarding
+        appUninstall_result1 = main.ONOScli1.feature_uninstall("onos-app-proxyarp")
+        appUninstall_result2 = main.ONOScli2.feature_uninstall("onos-app-proxyarp")
+        appUninstall_result3 = main.ONOScli3.feature_uninstall("onos-app-proxyarp")
+        main.log.info("onos-app-proxyarp uninstalled") 
+
+        main.step("Changing ipaddress of hosts h8,h9 and h18")
+        main.Mininet1.changeIP(host='h8', intf='h8-eth0', newIP='10.0.1.1', newNetmask='255.255.255.0') 
+        main.Mininet1.changeIP(host='h9', intf='h9-eth0', newIP='10.0.2.1', newNetmask='255.255.255.0')
+        main.Mininet1.changeIP(host='h10', intf='h10-eth0', newIP='10.0.3.1', newNetmask='255.255.255.0')
+
+        main.step("Changing default gateway of hosts h8,h9 and h18")
+        main.Mininet1.changeDefaultGateway(host='h8', newGW='10.0.1.254')
+        main.Mininet1.changeDefaultGateway(host='h9', newGW='10.0.2.254')
+        main.Mininet1.changeDefaultGateway(host='h10', newGW='10.0.3.254')
+
+        main.step("Assigning random mac address to the default gateways since proxyarp app is uninstalled")
+        main.Mininet1.addStaticMACAddress(host='h8', GW='10.0.1.254', macaddr='00:00:00:00:11:11')
+        main.Mininet1.addStaticMACAddress(host='h9', GW='10.0.2.254', macaddr='00:00:00:00:22:22')
+        main.Mininet1.addStaticMACAddress(host='h10', GW='10.0.3.254', macaddr='00:00:00:00:33:33')
+         
+        main.step("Verify static gateway and MAC address assignment")
+        main.Mininet1.verifyStaticGWandMAC(host='h8')
+        main.Mininet1.verifyStaticGWandMAC(host='h9')
+        main.Mininet1.verifyStaticGWandMAC(host='h10')
+        
+        main.step("Adding multipoint to singlepoint intent")               
+        p_intent_result1 = main.ONOScli1.add_multipoint_to_singlepoint_intent(ingress_device1=main.params['MULTIPOINT_INTENT']['device1'], ingress_device2=main.params['MULTIPOINT_INTENT']['device2'],
+                                 egress_device=main.params['MULTIPOINT_INTENT']['device3'], ipDst=main.params['MULTIPOINT_INTENT']['ip1'], setEthDst=main.params['MULTIPOINT_INTENT']['mac1']) 
+        
+        p_intent_result2 = main.ONOScli1.add_multipoint_to_singlepoint_intent(ingress_device1=main.params['MULTIPOINT_INTENT']['device3'], ingress_device2=main.params['MULTIPOINT_INTENT']['device2'],                            
+                                egress_device=main.params['MULTIPOINT_INTENT']['device1'], ipDst=main.params['MULTIPOINT_INTENT']['ip2'], setEthDst=main.params['MULTIPOINT_INTENT']['mac2'])    
+
+
+        get_intent_result = main.ONOScli1.intents(json_format = False)
+        main.log.info("intents = "+ get_intent_result)
+        
+        time.sleep(10)
+        get_flows_result = main.ONOScli1.flows(json_format = False)
+        main.log.info("flows = " + get_flows_result) 
+
+        count = 1
+        i = 8
+        Ping_Result = main.TRUE
+       
+        main.log.info("\n\nh"+str(i)+" is Pinging h" + str(i+2))
+        ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+2))
+        if ping == main.FALSE and count <3:
+            count+=1
+            Ping_Result = main.FALSE
+            main.log.report("Ping between h" + str(i) + " and h" + str(i+2) + " failed. Making attempt number "+str(count) + " in 2 seconds")
+            time.sleep(2)
+        elif ping==main.FALSE:
+            main.log.report("All ping attempts between h" + str(i) + " and h" + str(i+10) +"have failed")
+            Ping_Result = main.FALSE
+        elif ping==main.TRUE:
+            main.log.info("Ping test between h" + str(i) + " and h" + str(i+2) + "passed!")
+            Ping_Result = main.TRUE
+        else:
+            main.log.info("Unknown error")
+            Ping_Result = main.ERROR
+        
+        if Ping_Result==main.FALSE:
+            main.log.report("Ping test failed.")
+            #main.cleanup()
+            #main.exit()
+        if Ping_Result==main.TRUE:
+            main.log.report("Ping all successful")
+
+
+        p_intent_result = p_intent_result1 and p_intent_result2
+        if p_intent_result ==main.TRUE:
+            main.log.info("Multi point intent with rewrite mac address installation successful")
+        else:
+            main.log.info("Multi point intent with rewrite mac address installation failed")
+      
+        case33_result = p_intent_result and Ping_Result
+        utilities.assert_equals(expect=main.TRUE, actual=case33_result,
+                onpass="Ping all test after multipoint to single point intent addition with rewrite mac address successful",
+                onfail="Ping all test after multipoint to single point intent addition with rewrite mac address failed")  
diff --git a/TestON/tests/MultiProd/MultiProd.bak1 b/TestON/tests/MultiProd/MultiProd.bak1
new file mode 100644
index 0000000..6b67f63
--- /dev/null
+++ b/TestON/tests/MultiProd/MultiProd.bak1
@@ -0,0 +1,1523 @@
+
+# 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 MultiProd:
+
+    def __init__( self ):
+        self.default = ''
+
+    def CASE1( self, main ):
+        """
+        Startup sequence:
+        cell <name>
+        onos-verify-cell
+        onos-remove-raft-logs
+        git pull
+        mvn clean install
+        onos-package
+        onos-install -f
+        onos-wait-for-start
+        """
+        cell_name = main.params[ 'ENV' ][ 'cellName' ]
+        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+        ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+        ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+        ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
+        ONOS2_port = main.params[ 'CTRL' ][ 'port2' ]
+        ONOS3_port = main.params[ 'CTRL' ][ 'port3' ]
+
+        main.case( "Setting up test environment" )
+        main.log.report(
+            "This testcase is testing setting up test environment" )
+        main.log.report( "__________________________________" )
+
+        main.step( "Applying cell variable to environment" )
+        cell_result1 = main.ONOSbench.set_cell( cell_name )
+        #cell_result2 = main.ONOScli1.set_cell( cell_name )
+        #cell_result3 = main.ONOScli2.set_cell( cell_name )
+        #cell_result4 = main.ONOScli3.set_cell( cell_name )
+        verify_result = main.ONOSbench.verify_cell()
+        cell_result = cell_result1
+
+        main.step( "Removing raft logs before a clen installation of ONOS" )
+        remove_log_Result = main.ONOSbench.onos_remove_raft_logs()
+
+        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( report=True )
+
+        if git_pull_result == 1:
+            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( "Creating a cell" )
+        # cell_create_result = main.ONOSbench.create_cell_file( **************
+        # )
+
+        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 )
+        onos3_install_result = main.ONOSbench.onos_install(
+            options="-f",
+            node=ONOS3_ip )
+        onos_install_result = onos1_install_result and onos2_install_result and onos3_install_result
+        if onos_install_result == main.TRUE:
+            main.log.report( "Installing ONOS package successful" )
+        else:
+            main.log.report( "Installing ONOS package failed" )
+
+        onos1_isup = main.ONOSbench.isup( ONOS1_ip )
+        onos2_isup = main.ONOSbench.isup( ONOS2_ip )
+        onos3_isup = main.ONOSbench.isup( ONOS3_ip )
+        onos_isup = onos1_isup and onos2_isup and onos3_isup
+        if onos_isup == main.TRUE:
+            main.log.report( "ONOS instances are up and ready" )
+        else:
+            main.log.report( "ONOS instances may not be up" )
+
+        main.step( "Starting ONOS service" )
+        start_result = main.TRUE
+        #start_result = main.ONOSbench.onos_start( ONOS1_ip )
+        startcli1 = main.ONOScli1.start_onos_cli( ONOS_ip=ONOS1_ip )
+        startcli2 = main.ONOScli2.start_onos_cli( ONOS_ip=ONOS2_ip )
+        startcli3 = main.ONOScli3.start_onos_cli( ONOS_ip=ONOS3_ip )
+        print startcli1
+        print startcli2
+        print startcli3
+
+        case1_result = ( package_result and
+                         cell_result and verify_result and onos_install_result and
+                         onos_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' ]
+        ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+        ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+        main.case( "Cleaning up test environment" )
+
+        main.step( "Testing ONOS kill function" )
+        kill_result1 = main.ONOSbench.onos_kill( ONOS1_ip )
+        kill_result2 = main.ONOSbench.onos_kill( ONOS2_ip )
+        kill_result3 = main.ONOSbench.onos_kill( ONOS3_ip )
+
+        main.step( "Stopping ONOS service" )
+        stop_result1 = main.ONOSbench.onos_stop( ONOS1_ip )
+        stop_result2 = main.ONOSbench.onos_stop( ONOS2_ip )
+        stop_result3 = main.ONOSbench.onos_stop( ONOS3_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' ]
+        ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+        ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+        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 )
+        cmd_result2 = main.ONOSbench.onos_cli( ONOS2_ip, cmdstr1 )
+        main.log.info( "onos command returned: " + cmd_result2 )
+        cmd_result3 = main.ONOSbench.onos_cli( ONOS3_ip, cmdstr1 )
+        main.log.info( "onos command returned: " + cmd_result3 )
+
+        main.step( "Sending command 'onos -w <onos-ip> onos:topology'" )
+        cmdstr2 = "onos:topology"
+        cmd_result4 = main.ONOSbench.onos_cli( ONOS1_ip, cmdstr2 )
+        main.log.info( "onos command returned: " + cmd_result4 )
+        cmd_result5 = main.ONOSbench.onos_cli( ONOS2_ip, cmdstr2 )
+        main.log.info( "onos command returned: " + cmd_result5 )
+        cmd_result6 = main.ONOSbench.onos_cli( ONOS6_ip, cmdstr2 )
+        main.log.info( "onos command returned: " + cmd_result6 )
+
+    def CASE4( self, main ):
+        import re
+        import time
+        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+        ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+        ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+        ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
+        ONOS2_port = main.params[ 'CTRL' ][ 'port2' ]
+        ONOS3_port = main.params[ 'CTRL' ][ 'port3' ]
+
+        main.log.report(
+            "This testcase is testing the assignment of all the switches to all controllers and discovering the hosts in reactive mode" )
+        main.log.report( "__________________________________" )
+        main.case( "Pingall Test(No intents are added)" )
+        main.step( "Assigning switches to controllers" )
+        for i in range( 1, 29 ):  # 1 to ( num of switches +1 )
+            main.Mininet1.assign_sw_controller(
+                sw=str( i ),
+                count=3,
+                ip1=ONOS1_ip,
+                port1=ONOS1_port,
+                ip2=ONOS2_ip,
+                port2=ONOS2_port,
+                ip3=ONOS3_ip,
+                port3=ONOS3_port )
+
+        switch_mastership = main.TRUE
+        for i in range( 1, 29 ):
+            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" )
+        # 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
+        if ping_result == main.TRUE:
+            main.log.report(
+                "Pingall Test in reactive mode to discover the hosts successful" )
+        else:
+            main.log.report(
+                "Pingall Test in reactive mode to discover the hosts failed" )
+
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case4_result,
+            onpass="Controller assignment and Pingall Test successful",
+            onfail="Controller assignment and Pingall Test NOT successful" )
+
+    def CASE5( self, main ):
+        import json
+        from subprocess import Popen, PIPE
+        # assumes that sts is already in you PYTHONPATH
+        from sts.topology.teston_topology import TestONTopology
+        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+        ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+        ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+        main.log.report(
+            "This testcase is testing if all ONOS nodes are in topology sync with mininet and its peer ONOS nodes" )
+        main.log.report( "__________________________________" )
+        main.case(
+            "Testing Mininet topology with the topology of multi instances ONOS" )
+        main.step( "Collecting topology information from ONOS" )
+        devices1 = main.ONOScli1.devices()
+        devices2 = main.ONOScli2.devices()
+        devices3 = main.ONOScli3.devices()
+        # print "devices1 = ", devices1
+        # print "devices2 = ", devices2
+        # print "devices3 = ", devices3
+        hosts1 = main.ONOScli1.hosts()
+        hosts2 = main.ONOScli2.hosts()
+        hosts3 = main.ONOScli3.hosts()
+        # print "hosts1 = ", hosts1
+        # print "hosts2 = ", hosts2
+        # print "hosts3 = ", hosts3
+        ports1 = main.ONOScli1.ports()
+        ports2 = main.ONOScli2.ports()
+        ports3 = main.ONOScli3.ports()
+        # print "ports1 = ", ports1
+        # print "ports2 = ", ports2
+        # print "ports3 = ", ports3
+        links1 = main.ONOScli1.links()
+        links2 = main.ONOScli2.links()
+        links3 = main.ONOScli3.links()
+        # print "links1 = ", links1
+        # print "links2 = ", links2
+        # print "links3 = ", links3
+
+        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" )
+
+        switches_results1 = main.Mininet1.compare_switches(
+            MNTopo,
+            json.loads( devices1 ) )
+        print "switches_Result1 = ", switches_results1
+        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" )
+
+        switches_results3 = main.Mininet1.compare_switches(
+            MNTopo,
+            json.loads( devices3 ) )
+        utilities.assert_equals( expect=main.TRUE, actual=switches_results3,
+                                 onpass="ONOS3 Switches view is correct",
+                                 onfail="ONOS3 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" )
+
+        ports_results3 =  main.Mininet1.compare_ports( MNTopo, json.loads( ports3 ) )
+        utilities.assert_equals( expect=main.TRUE, actual=ports_results3,
+                onpass="ONOS3 Ports view is correct",
+                onfail="ONOS3 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" )
+
+        links_results3 = main.Mininet1.compare_links(
+            MNTopo,
+            json.loads( links3 ) )
+        utilities.assert_equals( expect=main.TRUE, actual=links_results3,
+                                 onpass="ONOS2 Links view is correct",
+                                 onfail="ONOS2 Links view is incorrect" )
+
+        #topo_result = switches_results1 and switches_results2 and switches_results3\
+        # and ports_results1 and ports_results2 and ports_results3\
+        # and links_results1 and links_results2 and links_results3
+
+        topo_result = switches_results1 and switches_results2 and switches_results3\
+            and links_results1 and links_results2 and links_results3
+
+        if topo_result == main.TRUE:
+            main.log.report(
+                "Topology Check Test with mininet and ONOS instances successful" )
+        else:
+            main.log.report(
+                "Topology Check Test with mininet and ONOS instances failed" )
+
+        utilities.assert_equals( expect=main.TRUE, actual=topo_result,
+                                 onpass="Topology Check Test successful",
+                                 onfail="Topology Check Test NOT successful" )
+
+    def CASE10( self ):
+        main.log.report(
+            "This testcase uninstalls the reactive forwarding app" )
+        main.log.report( "__________________________________" )
+        main.case( "Uninstalling reactive forwarding app" )
+        # Unistall onos-app-fwd app to disable reactive forwarding
+        appUninstall_result1 = main.ONOScli1.feature_uninstall(
+            "onos-app-fwd" )
+        appUninstall_result2 = main.ONOScli2.feature_uninstall(
+            "onos-app-fwd" )
+        appUninstall_result3 = main.ONOScli3.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 )
+
+        hosts = main.ONOScli1.hosts()
+        main.log.info( hosts )
+
+        case10_result = appUninstall_result1 and appUninstall_result2 and appUninstall_result3
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case10_result,
+            onpass="Reactive forwarding app uninstallation successful",
+            onfail="Reactive forwarding app uninstallation failed" )
+
+    def CASE6( self ):
+        main.log.report(
+            "This testcase is testing the addition of host intents and then doing pingall" )
+        main.log.report( "__________________________________" )
+        main.case( "Obtaining hostsfor adding host intents" )
+        main.step( "Get hosts" )
+        hosts = main.ONOScli1.hosts()
+        main.log.info( hosts )
+
+        main.step( "Get all devices id" )
+        devices_id_list = main.ONOScli1.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 intents for mn hosts(h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,h15-h25,h16-h26,h17-h27)" )
+        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1" )
+        """
+        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 )
+
+        flowHandle = main.ONOScli1.flows()
+        # print "flowHandle = ", flowHandle
+        main.log.info( "flows:" + flowHandle )
+
+        count = 1
+        i = 8
+        Ping_Result = main.TRUE
+        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 between h" +
+                                 str( i ) +
+                                 " and h" +
+                                 str( i +
+                                      10 ) +
+                                 "have failed" )
+                i = 19
+                Ping_Result = main.FALSE
+            elif ping == main.TRUE:
+                main.log.info( "Ping test between h" +
+                               str( i ) +
+                               " and h" +
+                               str( i +
+                                    10 ) +
+                               "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(
+                "Host intents have not ben installed correctly. Cleaning up" )
+            # main.cleanup()
+            # main.exit()
+        if Ping_Result == main.TRUE:
+            main.log.report( "Host intents have been installed correctly" )
+
+        case6_result = Ping_Result
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case6_result,
+            onpass="Host intent addition and Pingall Test successful",
+            onfail="Host intent addition and Pingall Test NOT successful" )
+
+    def CASE7( self, main ):
+
+        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+        link_sleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
+
+        main.log.report(
+            "This testscase is killing a link to ensure that link discovery is consistent" )
+        main.log.report( "__________________________________" )
+        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.ONOScli1.topology()
+        topology_result = main.ONOSbench.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.ONOScli2.topology()
+        Link_Down = main.ONOSbench.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.ONOScli2.topology()
+        Link_Up = main.ONOSbench.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" )
+        main.case(
+            "Testing Mininet topology with the topology of multi instances ONOS" )
+        main.step( "Collecting topology information from ONOS" )
+        devices1 = main.ONOScli1.devices()
+        devices2 = main.ONOScli2.devices()
+        devices3 = main.ONOScli3.devices()
+        print "devices1 = ", devices1
+        print "devices2 = ", devices2
+        print "devices3 = ", devices3
+        hosts1 = main.ONOScli1.hosts()
+        hosts2 = main.ONOScli2.hosts()
+        hosts3 = main.ONOScli3.hosts()
+        # print "hosts1 = ", hosts1
+        # print "hosts2 = ", hosts2
+        # print "hosts3 = ", hosts3
+        ports1 = main.ONOScli1.ports()
+        ports2 = main.ONOScli2.ports()
+        ports3 = main.ONOScli3.ports()
+        # print "ports1 = ", ports1
+        # print "ports2 = ", ports2
+        # print "ports3 = ", ports3
+        links1 = main.ONOScli1.links()
+        links2 = main.ONOScli2.links()
+        links3 = main.ONOScli3.links()
+        # print "links1 = ", links1
+        # print "links2 = ", links2
+        # print "links3 = ", links3
+
+        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" )
+
+        switches_results1 = main.Mininet1.compare_switches(
+            MNTopo,
+            json.loads( devices1 ) )
+        print "switches_Result1 = ", switches_results1
+        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" )
+
+        switches_results3 = main.Mininet1.compare_switches(
+            MNTopo,
+            json.loads( devices3 ) )
+        utilities.assert_equals( expect=main.TRUE, actual=switches_results3,
+                                 onpass="ONOS3 Switches view is correct",
+                                 onfail="ONOS3 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" )
+
+        ports_results3 =  main.Mininet1.compare_ports( MNTopo, json.loads( ports3 ) )
+        utilities.assert_equals( expect=main.TRUE, actual=ports_results3,
+                onpass="ONOS3 Ports view is correct",
+                onfail="ONOS3 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" )
+
+        links_results3 = main.Mininet1.compare_links(
+            MNTopo,
+            json.loads( links3 ) )
+        utilities.assert_equals( expect=main.TRUE, actual=links_results3,
+                                 onpass="ONOS2 Links view is correct",
+                                 onfail="ONOS2 Links view is incorrect" )
+
+        #topo_result = switches_results1 and switches_results2 and switches_results3\
+        # and ports_results1 and ports_results2 and ports_results3\
+        # and links_results1 and links_results2 and links_results3
+
+        topo_result = switches_results1 and switches_results2 and switches_results3\
+            and links_results1 and links_results2 and links_results3
+
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=topo_result and Link_Up and Link_Down,
+            onpass="Topology Check Test successful",
+            onfail="Topology Check Test NOT successful" )
+
+    def CASE8( self ):
+        """
+        Intent removal
+        """
+        main.log.report(
+            "This testcase removes host any previously added intents" )
+        main.log.report( "__________________________________" )
+        main.log.info( "Removing any previously installed intents" )
+        main.case( "Removing intents" )
+        main.step( "Obtain the intent id's" )
+        intent_result = main.ONOScli1.intents( json_format=False )
+
+        intent_linewise = intent_result.split( "\n" )
+        intentList = []
+        for line in intent_linewise:
+            if line.startswith( "id=" ):
+                intentList.append( line )
+
+        intentids = []
+        for line in intentList:
+            intentids.append( line.split( "," )[ 0 ].split( "=" )[ 1 ] )
+        for id in intentids:
+            main.log.info( "id = " + id )
+
+        main.step(
+            "Iterate through the intentids list and remove each intent" )
+        for id in intentids:
+            main.ONOScli1.remove_intent( intent_id=id )
+
+        intent_result = main.ONOScli1.intents( json_format=False )
+        main.log.info( "intent_result = " + intent_result )
+        case8_result = main.TRUE
+
+        i = 8
+        Ping_Result = main.TRUE
+        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.TRUE:
+                i = 19
+                Ping_Result = main.TRUE
+            elif ping == main.FALSE:
+                i += 1
+                Ping_Result = main.FALSE
+            else:
+                main.log.info( "Unknown error" )
+                Ping_Result = main.ERROR
+
+        # Note: If the ping result failed, that means the intents have been
+        # withdrawn correctly.
+        if Ping_Result == main.TRUE:
+            main.log.report( "Host intents have not been withdrawn correctly" )
+            # main.cleanup()
+            # main.exit()
+        if Ping_Result == main.FALSE:
+            main.log.report( "Host intents have been withdrawn correctly" )
+
+        case8_result = case8_result and Ping_Result
+
+        if case8_result == main.FALSE:
+            main.log.report( "Intent removal successful" )
+        else:
+            main.log.report( "Intent removal failed" )
+
+        utilities.assert_equals( expect=main.FALSE, actual=case8_result,
+                                 onpass="Intent removal test failed",
+                                 onfail="Intent removal test successful" )
+
+    def CASE9( self ):
+        """
+        This test case adds point intents. Make sure you run test case 8 which is host intent removal before executing this test case.
+        Else the host intent's flows will persist on switches and the pings would work even if there is some issue with the point intent's flows
+        """
+        main.log.report(
+            "This testcase adds point intents and then does pingall" )
+        main.log.report( "__________________________________" )
+        main.log.info( "Adding point intents" )
+        main.case(
+            "Adding bidirectional point for mn hosts(h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,h15-h25,h16-h26,h17-h27)" )
+        main.step(
+            "Add point-to-point intents for mininet hosts h8 and h18 or ONOS hosts h8 and h12" )
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000003008/1",
+            "of:0000000000006018/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006018/1",
+            "of:0000000000003008/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003009/1",
+            "of:0000000000006019/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006019/1",
+            "of:0000000000003009/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003010/1",
+            "of:0000000000006020/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006020/1",
+            "of:0000000000003010/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003011/1",
+            "of:0000000000006021/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006021/1",
+            "of:0000000000003011/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003012/1",
+            "of:0000000000006022/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006022/1",
+            "of:0000000000003012/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003013/1",
+            "of:0000000000006023/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006023/1",
+            "of:0000000000003013/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003014/1",
+            "of:0000000000006024/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006024/1",
+            "of:0000000000003014/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003015/1",
+            "of:0000000000006025/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006025/1",
+            "of:0000000000003015/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003016/1",
+            "of:0000000000006026/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006026/1",
+            "of:0000000000003016/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003017/1",
+            "of:0000000000006027/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006027/1",
+            "of:0000000000003017/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        print(
+            "_______________________________________________________________________________________" )
+
+        flowHandle = main.ONOScli1.flows()
+        # print "flowHandle = ", flowHandle
+        main.log.info( "flows :" + flowHandle )
+
+        count = 1
+        i = 8
+        Ping_Result = main.TRUE
+        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 between h" +
+                                 str( i ) +
+                                 " and h" +
+                                 str( i +
+                                      10 ) +
+                                 "have failed" )
+                i = 19
+                Ping_Result = main.FALSE
+            elif ping == main.TRUE:
+                main.log.info( "Ping test between h" +
+                               str( i ) +
+                               " and h" +
+                               str( i +
+                                    10 ) +
+                               "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(
+                "Ping all test after Point intents addition failed. Cleaning up" )
+            # main.cleanup()
+            # main.exit()
+        if Ping_Result == main.TRUE:
+            main.log.report(
+                "Ping all test after Point intents addition successful" )
+
+        case8_result = Ping_Result
+        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 CASE31( self ):
+        """
+            This test case adds point intent related to SDN-IP matching on ICMP ( ethertype=IPV4, ipProto=1 )
+        """
+        import json
+
+        main.log.report(
+            "This test case adds point intent related to SDN-IP matching on ICMP" )
+        main.case(
+            "Adding bidirectional point intent related to SDN-IP matching on ICMP" )
+        main.step( "Adding bidirectional point intent" )
+        # add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32
+        # --ethType=IPV4 --ipProto=1  of:0000000000003008/1
+        # of:0000000000006018/1
+
+        hosts_json = json.loads( main.ONOScli1.hosts() )
+        for i in range( 8, 11 ):
+            main.log.info(
+                "Adding point 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()
+            host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
+            host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
+            for host in hosts_json:
+                if host[ 'id' ] == host1_id:
+                    ip1 = host[ 'ips' ][ 0 ]
+                    ip1 = str( ip1 + "/32" )
+                    device1 = host[ 'location' ][ 'device' ]
+                    device1 = str( device1 + "/1" )
+                elif host[ 'id' ] == host2_id:
+                    ip2 = str( host[ 'ips' ][ 0 ] ) + "/32"
+                    device2 = host[ 'location' ][ "device" ]
+                    device2 = str( device2 + "/1" )
+
+            p_intent_result1 = main.ONOScli1.add_point_intent(
+                ingress_device=device1,
+                egress_device=device2,
+                ipSrc=ip1,
+                ipDst=ip2,
+                ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+                ipProto=main.params[ 'SDNIP' ][ 'icmpProto' ] )
+
+            get_intent_result = main.ONOScli1.intents( json_format=False )
+            main.log.info( get_intent_result )
+
+            p_intent_result2 = main.ONOScli1.add_point_intent(
+                ingress_device=device2,
+                egress_device=device1,
+                ipSrc=ip2,
+                ipDst=ip1,
+                ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+                ipProto=main.params[ 'SDNIP' ][ 'icmpProto' ] )
+
+            get_intent_result = main.ONOScli1.intents( json_format=False )
+            main.log.info( get_intent_result )
+            if ( p_intent_result1 and p_intent_result2 ) == main.TRUE:
+                #get_intent_result = main.ONOScli1.intents()
+                # main.log.info( get_intent_result )
+                main.log.info(
+                    "Point intent related to SDN-IP matching on ICMP install successful" )
+
+        time.sleep( 15 )
+        get_intent_result = main.ONOScli1.intents( json_format=False )
+        main.log.info( "intents = " + get_intent_result )
+        get_flows_result = main.ONOScli1.flows()
+        main.log.info( "flows = " + get_flows_result )
+
+        count = 1
+        i = 8
+        Ping_Result = main.TRUE
+        while i < 11:
+            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 < 3:
+                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 between h" +
+                                 str( i ) +
+                                 " and h" +
+                                 str( i +
+                                      10 ) +
+                                 "have failed" )
+                i = 19
+                Ping_Result = main.FALSE
+            elif ping == main.TRUE:
+                main.log.info( "Ping test between h" +
+                               str( i ) +
+                               " and h" +
+                               str( i +
+                                    10 ) +
+                               "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(
+                "Ping test after Point intents related to SDN-IP matching on ICMP failed." )
+            # main.cleanup()
+            # main.exit()
+        if Ping_Result == main.TRUE:
+            main.log.report(
+                "Ping all test after Point intents related to SDN-IP matching on ICMP successful" )
+
+        case31_result = Ping_Result and p_intent_result1 and p_intent_result2
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case31_result,
+            onpass="Point intent related to SDN-IP matching on ICMP and ping test successful",
+            onfail="Point intent related to SDN-IP matching on ICMP and ping test failed" )
+
+    def CASE32( self ):
+        """
+            This test case adds point intent related to SDN-IP matching on TCP ( ethertype=IPV4, ipProto=6, DefaultPort for iperf=5001 )
+            Note: Although BGP port is 179, we are using 5001 because iperf is used for verifying and iperf's default port is 5001
+        """
+        import json
+
+        main.log.report(
+            "This test case adds point intent related to SDN-IP matching on TCP" )
+        main.case(
+            "Adding bidirectional point intent related to SDN-IP matching on TCP" )
+        main.step( "Adding bidirectional point intent" )
+        """
+        add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32 --ethType=IPV4 --ipProto=6 --tcpDst=5001  of:0000000000003008/1 of:0000000000006018/1
+
+        add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32 --ethType=IPV4 --ipProto=6 --tcpDst=5001  of:0000000000006018/1 of:0000000000003008/1
+
+        add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32 --ethType=IPV4 --ipProto=6 --tcpSrc=5001  of:0000000000003008/1 of:0000000000006018/1
+
+        add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32 --ethType=IPV4 --ipProto=6 --tcpSrc=5001  of:0000000000006018/1 of:0000000000003008/1
+
+        """
+        hosts_json = json.loads( main.ONOScli1.hosts() )
+        for i in range( 8, 9 ):
+            main.log.info(
+                "Adding point 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()
+            host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
+            host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
+            for host in hosts_json:
+                if host[ 'id' ] == host1_id:
+                    ip1 = host[ 'ips' ][ 0 ]
+                    ip1 = str( ip1 + "/32" )
+                    device1 = host[ 'location' ][ 'device' ]
+                    device1 = str( device1 + "/1" )
+                elif host[ 'id' ] == host2_id:
+                    ip2 = str( host[ 'ips' ][ 0 ] ) + "/32"
+                    device2 = host[ 'location' ][ "device" ]
+                    device2 = str( device2 + "/1" )
+
+            p_intent_result1 = main.ONOScli1.add_point_intent(
+                ingress_device=device1,
+                egress_device=device2,
+                ipSrc=ip1,
+                ipDst=ip2,
+                ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+                ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+                tcpDst=main.params[ 'SDNIP' ][ 'dstPort' ] )
+            p_intent_result2 = main.ONOScli1.add_point_intent(
+                ingress_device=device2,
+                egress_device=device1,
+                ipSrc=ip2,
+                ipDst=ip1,
+                ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+                ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+                tcpDst=main.params[ 'SDNIP' ][ 'dstPort' ] )
+
+            p_intent_result3 = main.ONOScli1.add_point_intent(
+                ingress_device=device1,
+                egress_device=device2,
+                ipSrc=ip1,
+                ipDst=ip2,
+                ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+                ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+                tcpSrc=main.params[ 'SDNIP' ][ 'srcPort' ] )
+            p_intent_result4 = main.ONOScli1.add_point_intent(
+                ingress_device=device2,
+                egress_device=device1,
+                ipSrc=ip2,
+                ipDst=ip1,
+                ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+                ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+                tcpSrc=main.params[ 'SDNIP' ][ 'srcPort' ] )
+
+            p_intent_result = p_intent_result1 and p_intent_result2 and p_intent_result3 and p_intent_result4
+            if p_intent_result == main.TRUE:
+                get_intent_result = main.ONOScli1.intents( json_format=False )
+                main.log.info( get_intent_result )
+                main.log.info(
+                    "Point intent related to SDN-IP matching on TCP install successful" )
+
+        iperf_result = main.Mininet1.iperf( 'h8', 'h18' )
+        if iperf_result == main.TRUE:
+            main.log.report( "iperf test successful" )
+        else:
+            main.log.report( "iperf test failed" )
+
+        case32_result = p_intent_result and iperf_result
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case32_result,
+            onpass="Ping all test after Point intents addition related to SDN-IP on TCP match successful",
+            onfail="Ping all test after Point intents addition related to SDN-IP on TCP match failed" )
+
+    def CASE33( self ):
+        """
+            This test case adds multipoint to singlepoint  intent related to SDN-IP matching on destination ip and the action is to rewrite the mac address
+            Here the mac address to be rewritten is the mac address of the egress device
+        """
+        import json
+        import time
+
+        main.log.report(
+            "This test case adds multipoint to singlepoint intent related to SDN-IP matching on destination ip and rewrite mac address action" )
+        main.case(
+            "Adding multipoint to singlepoint intent related to SDN-IP matching on destination ip" )
+        main.step( "Adding bidirectional multipoint to singlepoint intent" )
+        """
+        add-multi-to-single-intent --ipDst=10.0.3.0/24 --setEthDst=00:00:00:00:00:12 of:0000000000003008/1 0000000000003009/1 of:0000000000006018/1
+
+        add-multi-to-single-intent --ipDst=10.0.1.0/24 --setEthDst=00:00:00:00:00:08 of:0000000000006018/1 0000000000003009/1 of:0000000000003008/1
+        """
+        main.case(
+            "Installing multipoint to single point intent with rewrite mac address" )
+        main.step( "Uninstalling proxy arp app" )
+        # Unistall onos-app-proxyarp app to disable reactive forwarding
+        appUninstall_result1 = main.ONOScli1.feature_uninstall(
+            "onos-app-proxyarp" )
+        appUninstall_result2 = main.ONOScli2.feature_uninstall(
+            "onos-app-proxyarp" )
+        appUninstall_result3 = main.ONOScli3.feature_uninstall(
+            "onos-app-proxyarp" )
+        main.log.info( "onos-app-proxyarp uninstalled" )
+
+        main.step( "Changing ipaddress of hosts h8,h9 and h18" )
+        main.Mininet1.changeIP(
+            host='h8',
+            intf='h8-eth0',
+            newIP='10.0.1.1',
+            newNetmask='255.255.255.0' )
+        main.Mininet1.changeIP(
+            host='h9',
+            intf='h9-eth0',
+            newIP='10.0.2.1',
+            newNetmask='255.255.255.0' )
+        main.Mininet1.changeIP(
+            host='h10',
+            intf='h10-eth0',
+            newIP='10.0.3.1',
+            newNetmask='255.255.255.0' )
+
+        main.step( "Changing default gateway of hosts h8,h9 and h18" )
+        main.Mininet1.changeDefaultGateway( host='h8', newGW='10.0.1.254' )
+        main.Mininet1.changeDefaultGateway( host='h9', newGW='10.0.2.254' )
+        main.Mininet1.changeDefaultGateway( host='h10', newGW='10.0.3.254' )
+
+        main.step(
+            "Assigning random mac address to the default gateways since proxyarp app is uninstalled" )
+        main.Mininet1.addStaticMACAddress(
+            host='h8',
+            GW='10.0.1.254',
+            macaddr='00:00:00:00:11:11' )
+        main.Mininet1.addStaticMACAddress(
+            host='h9',
+            GW='10.0.2.254',
+            macaddr='00:00:00:00:22:22' )
+        main.Mininet1.addStaticMACAddress(
+            host='h10',
+            GW='10.0.3.254',
+            macaddr='00:00:00:00:33:33' )
+
+        main.step( "Verify static gateway and MAC address assignment" )
+        main.Mininet1.verifyStaticGWandMAC( host='h8' )
+        main.Mininet1.verifyStaticGWandMAC( host='h9' )
+        main.Mininet1.verifyStaticGWandMAC( host='h10' )
+
+        main.step( "Adding multipoint to singlepoint intent" )
+        p_intent_result1 = main.ONOScli1.add_multipoint_to_singlepoint_intent(
+            ingress_device1=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
+            ingress_device2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+            egress_device=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
+            ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip1' ],
+            setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac1' ] )
+
+        p_intent_result2 = main.ONOScli1.add_multipoint_to_singlepoint_intent(
+            ingress_device1=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
+            ingress_device2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+            egress_device=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
+            ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip2' ],
+            setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac2' ] )
+
+        get_intent_result = main.ONOScli1.intents( json_format=False )
+        main.log.info( "intents = " + get_intent_result )
+
+        time.sleep( 10 )
+        get_flows_result = main.ONOScli1.flows( json_format=False )
+        main.log.info( "flows = " + get_flows_result )
+
+        count = 1
+        i = 8
+        Ping_Result = main.TRUE
+
+        main.log.info( "\n\nh" + str( i ) + " is Pinging h" + str( i + 2 ) )
+        ping = main.Mininet1.pingHost(
+            src="h" + str( i ), target="h" + str( i + 2 ) )
+        if ping == main.FALSE and count < 3:
+            count += 1
+            Ping_Result = main.FALSE
+            main.log.report( "Ping between h" +
+                             str( i ) +
+                             " and h" +
+                             str( i +
+                                  2 ) +
+                             " failed. Making attempt number " +
+                             str( count ) +
+                             " in 2 seconds" )
+            time.sleep( 2 )
+        elif ping == main.FALSE:
+            main.log.report( "All ping attempts between h" +
+                             str( i ) +
+                             " and h" +
+                             str( i +
+                                  10 ) +
+                             "have failed" )
+            Ping_Result = main.FALSE
+        elif ping == main.TRUE:
+            main.log.info( "Ping test between h" +
+                           str( i ) +
+                           " and h" +
+                           str( i +
+                                2 ) +
+                           "passed!" )
+            Ping_Result = main.TRUE
+        else:
+            main.log.info( "Unknown error" )
+            Ping_Result = main.ERROR
+
+        if Ping_Result == main.FALSE:
+            main.log.report( "Ping test failed." )
+            # main.cleanup()
+            # main.exit()
+        if Ping_Result == main.TRUE:
+            main.log.report( "Ping all successful" )
+
+        p_intent_result = p_intent_result1 and p_intent_result2
+        if p_intent_result == main.TRUE:
+            main.log.info(
+                "Multi point intent with rewrite mac address installation successful" )
+        else:
+            main.log.info(
+                "Multi point intent with rewrite mac address installation failed" )
+
+        case33_result = p_intent_result and Ping_Result
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case33_result,
+            onpass="Ping all test after multipoint to single point intent addition with rewrite mac address successful",
+            onfail="Ping all test after multipoint to single point intent addition with rewrite mac address failed" )
diff --git a/TestON/tests/MultiProd/MultiProd.params b/TestON/tests/MultiProd/MultiProd.params
index 8bf1600..6e5c85e 100755
--- a/TestON/tests/MultiProd/MultiProd.params
+++ b/TestON/tests/MultiProd/MultiProd.params
@@ -1,6 +1,6 @@
 <PARAMS>
     
-    <testcases>1,4,10,5,6,7,8,6,8,9,31,32,8,33</testcases>    
+    <testcases>1,4,10,5,6,7,8,6,8,9,8,31,32,8,33,8</testcases>    
 
     #Environment variables
     <ENV>
diff --git a/TestON/tests/MultiProd/MultiProd.py b/TestON/tests/MultiProd/MultiProd.py
index ea61a25..d3ed757 100644
--- a/TestON/tests/MultiProd/MultiProd.py
+++ b/TestON/tests/MultiProd/MultiProd.py
@@ -11,7 +11,6 @@
 
 time.sleep( 1 )
 
-
 class MultiProd:
 
     def __init__( self ):
@@ -53,8 +52,8 @@
         main.step( "Removing raft logs before a clen installation of ONOS" )
         removeLogResult = main.ONOSbench.onosRemoveRaftLogs()
 
-        main.step( "Git checkout and pull master and get version" )
-        main.ONOSbench.gitCheckout( "master" )
+        main.step( "Git checkout, pull and get version" )
+        #main.ONOSbench.gitCheckout( "master" )
         gitPullResult = main.ONOSbench.gitPull()
         print "git_pull_result = ", gitPullResult
         versionResult = main.ONOSbench.getVersion( report=True )
@@ -514,7 +513,6 @@
             tmpResult = main.ONOScli1.addHostIntent( host1Id, host2Id )
 
         flowHandle = main.ONOScli1.flows()
-        # print "flowHandle = ", flowHandle
         main.log.info( "flows:" + flowHandle )
 
         count = 1
@@ -857,7 +855,7 @@
         Intent removal
         """
         main.log.report(
-            "This testcase removes host any previously added intents" )
+            "This testcase removes any previously added intents" )
         main.log.report( "__________________________________" )
         main.log.info( "Removing any previously installed intents" )
         main.case( "Removing intents" )
@@ -1424,9 +1422,13 @@
             if pIntentResult == main.TRUE:
                 getIntentResult = main.ONOScli1.intents( jsonFormat=False )
                 main.log.info( getIntentResult )
-                main.log.info(
+                main.log.report(
                     "Point intent related to SDN-IP matching" +
                     " on TCP install successful" )
+            else:
+                main.log.report(
+                    "Point intent related to SDN-IP matching" +
+                    " on TCP install failed" )
 
         iperfResult = main.Mininet1.iperf( 'h8', 'h18' )
         if iperfResult == main.TRUE:
diff --git a/TestON/tests/MultiProd/MultiProd.py.fixed b/TestON/tests/MultiProd/MultiProd.py.fixed
new file mode 100644
index 0000000..e0e772a
--- /dev/null
+++ b/TestON/tests/MultiProd/MultiProd.py.fixed
@@ -0,0 +1,1566 @@
+
+# Testing the basic functionality of ONOS Next
+# For sanity and driver functionality excercises only.
+
+import time
+import json
+
+time.sleep( 1 )
+
+
+class MultiProd:
+
+    def __init__( self ):
+        self.default = ''
+
+    def CASE1( self, main ):
+        """
+        Startup sequence:
+        cell <name>
+        onos-verify-cell
+        onos-remove-raft-logs
+        git pull
+        mvn clean install
+        onos-package
+        onos-install -f
+        onos-wait-for-start
+        """
+        cell_name = main.params[ 'ENV' ][ 'cellName' ]
+        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+        ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+        ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+        main.case( "Setting up test environment" )
+        main.log.report(
+            "This testcase is testing setting up test environment" )
+        main.log.report( "__________________________________" )
+
+        main.step( "Applying cell variable to environment" )
+        cell_result1 = main.ONOSbench.set_cell( cell_name )
+        # cell_result2 = main.ONOScli1.set_cell( cell_name )
+        # cell_result3 = main.ONOScli2.set_cell( cell_name )
+        # cell_result4 = main.ONOScli3.set_cell( cell_name )
+        verify_result = main.ONOSbench.verify_cell()
+        cell_result = cell_result1
+
+        main.step( "Removing raft logs before a clen installation of ONOS" )
+        main.ONOSbench.onos_remove_raft_logs()
+
+        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
+        main.ONOSbench.get_version( report=True )
+
+        if git_pull_result == 1:
+            main.step( "Using mvn clean & install" )
+            main.ONOSbench.clean_install()
+
+        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" )
+        onos1_install_result = main.ONOSbench.onos_install(
+            options="-f",
+            node=ONOS1_ip )
+        onos2_install_result = main.ONOSbench.onos_install(
+            options="-f",
+            node=ONOS2_ip )
+        onos3_install_result = main.ONOSbench.onos_install(
+            options="-f",
+            node=ONOS3_ip )
+        onos_install_result = onos1_install_result and onos2_install_result \
+                                and onos3_install_result
+        if onos_install_result == main.TRUE:
+            main.log.report( "Installing ONOS package successful" )
+        else:
+            main.log.report( "Installing ONOS package failed" )
+
+        onos1_isup = main.ONOSbench.isup( ONOS1_ip )
+        onos2_isup = main.ONOSbench.isup( ONOS2_ip )
+        onos3_isup = main.ONOSbench.isup( ONOS3_ip )
+        onos_isup = onos1_isup and onos2_isup and onos3_isup
+        if onos_isup == main.TRUE:
+            main.log.report( "ONOS instances are up and ready" )
+        else:
+            main.log.report( "ONOS instances may not be up" )
+
+        main.step( "Starting ONOS service" )
+        start_result = main.TRUE
+        # start_result = main.ONOSbench.onos_start( ONOS1_ip )
+        startcli1 = main.ONOScli1.start_onos_cli( ONOS_ip=ONOS1_ip )
+        startcli2 = main.ONOScli2.start_onos_cli( ONOS_ip=ONOS2_ip )
+        startcli3 = main.ONOScli3.start_onos_cli( ONOS_ip=ONOS3_ip )
+        print startcli1
+        print startcli2
+        print startcli3
+
+        case1_result = ( package_result and cell_result and
+                         verify_result and onos_install_result
+                         and onos_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' ]
+        ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+        ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+        main.case( "Cleaning up test environment" )
+
+        main.step( "Testing ONOS kill function" )
+        kill_result1 = main.ONOSbench.onos_kill( ONOS1_ip )
+        kill_result2 = main.ONOSbench.onos_kill( ONOS2_ip )
+        kill_result3 = main.ONOSbench.onos_kill( ONOS3_ip )
+        kill_result = kill_result1 and kill_result2 and kill_result3
+
+        main.step( "Stopping ONOS service" )
+        stop_result1 = main.ONOSbench.onos_stop( ONOS1_ip )
+        stop_result2 = main.ONOSbench.onos_stop( ONOS2_ip )
+        stop_result3 = main.ONOSbench.onos_stop( ONOS3_ip )
+        stop_result = stop_result1 and stop_result2 and stop_result3
+ 
+        main.step( "Uninstalling ONOS service" )
+        uninstall_result = main.ONOSbench.onos_uninstall()
+
+        case11_result = kill_result and stop_result and uninstall_result
+        utilities.assert_equals( expect=main.TRUE, actual=case11_result,
+                                 onpass="Cleanup successful",
+                                 onfail="Cleanup failed" )
+
+    def CASE3( self, main ):
+        """
+        Test 'onos' command and its functionality in driver
+        """
+        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+        ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+        ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+        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 )
+        cmd_result2 = main.ONOSbench.onos_cli( ONOS2_ip, cmdstr1 )
+        main.log.info( "onos command returned: " + cmd_result2 )
+        cmd_result3 = main.ONOSbench.onos_cli( ONOS3_ip, cmdstr1 )
+        main.log.info( "onos command returned: " + cmd_result3 )
+
+        main.step( "Sending command 'onos -w <onos-ip> onos:topology'" )
+        cmdstr2 = "onos:topology"
+        cmd_result4 = main.ONOSbench.onos_cli( ONOS1_ip, cmdstr2 )
+        main.log.info( "onos command returned: " + cmd_result4 )
+        cmd_result5 = main.ONOSbench.onos_cli( ONOS2_ip, cmdstr2 )
+        main.log.info( "onos command returned: " + cmd_result5 )
+        cmd_result6 = main.ONOSbench.onos_cli( ONOS3_ip, cmdstr2 )
+        main.log.info( "onos command returned: " + cmd_result6 )
+
+    def CASE4( self, main ):
+        import re
+        import time
+        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+        ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+        ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+        ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
+        ONOS2_port = main.params[ 'CTRL' ][ 'port2' ]
+        ONOS3_port = main.params[ 'CTRL' ][ 'port3' ]
+
+        main.log.report(
+            "This testcase is testing the assignment of all the switches to \
+            all controllers and discovering the hosts in reactive mode" )
+        main.log.report( "__________________________________" )
+        main.case( "Pingall Test(No intents are added)" )
+        main.step( "Assigning switches to controllers" )
+        for i in range( 1, 29 ):  # 1 to ( num of switches +1 )
+            main.Mininet1.assign_sw_controller(
+                sw=str( i ),
+                count=3,
+                ip1=ONOS1_ip,
+                port1=ONOS1_port,
+                ip2=ONOS2_ip,
+                port2=ONOS2_port,
+                ip3=ONOS3_ip,
+                port3=ONOS3_port )
+
+        switch_mastership = main.TRUE
+        for i in range( 1, 29 ):
+            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" )
+        # 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
+        if ping_result == main.TRUE:
+            main.log.report( "Pingall Test in reactive mode to discover \
+                             the hosts successful" )
+        else:
+            main.log.report( "Pingall Test in reactive mode to discover \
+                             the hosts failed" )
+
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case4_result,
+            onpass="Controller assignment and Pingall Test successful",
+            onfail="Controller assignment and Pingall Test NOT successful" )
+
+    def CASE5( self, main ):
+        import json
+        from subprocess import Popen, PIPE
+        # assumes that sts is already in you PYTHONPATH
+        from sts.topology.teston_topology import TestONTopology
+
+        main.log.report( "This testcase is testing if all ONOS nodes are in \
+                         topology sync with mininet and its peer ONOS nodes" )
+        main.log.report( "__________________________________" )
+        main.case(
+            "Testing Mininet topology with the topology \
+            of multi instances ONOS" )
+        main.step( "Collecting topology information from ONOS" )
+        devices1 = main.ONOScli1.devices()
+        devices2 = main.ONOScli2.devices()
+        devices3 = main.ONOScli3.devices()
+        hosts1 = main.ONOScli1.hosts()
+        hosts2 = main.ONOScli2.hosts()
+        hosts3 = main.ONOScli3.hosts()
+        ports1 = main.ONOScli1.ports()
+        ports2 = main.ONOScli2.ports()
+        ports3 = main.ONOScli3.ports()
+        links1 = main.ONOScli1.links()
+        links2 = main.ONOScli2.links()
+        links3 = main.ONOScli3.links()
+
+        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" )
+
+        switches_results1 = main.Mininet1.compare_switches(
+            MNTopo,
+            json.loads( devices1 ) )
+        print "switches_Result1 = ", switches_results1
+        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" )
+
+        switches_results3 = main.Mininet1.compare_switches(
+            MNTopo,
+            json.loads( devices3 ) )
+        utilities.assert_equals( expect=main.TRUE, actual=switches_results3,
+                                 onpass="ONOS3 Switches view is correct",
+                                 onfail="ONOS3 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" )
+
+        ports_results3 = main.Mininet1.compare_ports(
+                            MNTopo, json.loads( ports3 ) )
+        utilities.assert_equals( expect=main.TRUE, actual=ports_results3,
+                onpass="ONOS3 Ports view is correct",
+                onfail="ONOS3 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" )
+
+        links_results3 = main.Mininet1.compare_links(
+            MNTopo,
+            json.loads( links3 ) )
+        utilities.assert_equals( expect=main.TRUE, actual=links_results3,
+                                 onpass="ONOS2 Links view is correct",
+                                 onfail="ONOS2 Links view is incorrect" )
+
+        topo_result = switches_results1 and switches_results2 and \
+        switches_results3\
+        and ports_results1 and ports_results2 and ports_results3\
+        and links_results1 and links_results2 and links_results3
+
+        '''
+            topo_result = switches_results1 and switches_results2 and \
+                        switches_results3 and links_results1 and \
+                        links_results2 and links_results3
+        '''
+
+        if topo_result == main.TRUE:
+            main.log.report(
+                "Topology Check Test with mininet and \
+                ONOS instances successful" )
+        else:
+            main.log.report(
+                "Topology Check Test with mininet and \
+                ONOS instances failed" )
+
+        utilities.assert_equals( expect=main.TRUE, actual=topo_result,
+                                 onpass="Topology Check Test successful",
+                                 onfail="Topology Check Test NOT successful" )
+
+    def CASE10( self ):
+        main.log.report(
+            "This testcase uninstalls the reactive forwarding app" )
+        main.log.report( "__________________________________" )
+        main.case( "Uninstalling reactive forwarding app" )
+        # Unistall onos-app-fwd app to disable reactive forwarding
+        appUninstall_result1 = main.ONOScli1.feature_uninstall(
+            "onos-app-fwd" )
+        appUninstall_result2 = main.ONOScli2.feature_uninstall(
+            "onos-app-fwd" )
+        appUninstall_result3 = main.ONOScli3.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 )
+
+        hosts = main.ONOScli1.hosts()
+        main.log.info( hosts )
+
+        case10_result = appUninstall_result1 and appUninstall_result2 and \
+                        appUninstall_result3
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case10_result,
+            onpass="Reactive forwarding app uninstallation successful",
+            onfail="Reactive forwarding app uninstallation failed" )
+
+    def CASE6( self ):
+        main.log.report(
+            "This testcase is testing the addition of host intents and \
+            then doing pingall" )
+        main.log.report( "__________________________________" )
+        main.case( "Obtaining hostsfor adding host intents" )
+        main.step( "Get hosts" )
+        hosts = main.ONOScli1.hosts()
+        main.log.info( hosts )
+
+        main.step( "Get all devices id" )
+        devices_id_list = main.ONOScli1.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 intents for mn hosts
+            (h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,
+            h15-h25,h16-h26,h17-h27)" )
+        hth_intent_result = main.ONOScli1.add_host_intent(
+                            "00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent(
+                            "00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent(
+                            "00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent(
+                            "00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent(
+                            "00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent(
+                            "00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent(
+                            "00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent(
+                            "00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent(
+                            "00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1" )
+        hth_intent_result = main.ONOScli1.add_host_intent(
+                            "00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1" )
+        """
+        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 )
+
+        flowHandle = main.ONOScli1.flows()
+        main.log.info( "flows:" + flowHandle )
+
+        count = 1
+        i = 8
+        Ping_Result = main.TRUE
+        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 between h" +
+                                 str( i ) +
+                                 " and h" +
+                                 str( i +
+                                      10 ) +
+                                 "have failed" )
+                i = 19
+                Ping_Result = main.FALSE
+            elif ping == main.TRUE:
+                main.log.info( "Ping test between h" +
+                               str( i ) +
+                               " and h" +
+                               str( i +
+                                    10 ) +
+                               "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(
+                "Host intents have not ben installed correctly. Cleaning up" )
+            # main.cleanup()
+            # main.exit()
+        if Ping_Result == main.TRUE:
+            main.log.report( "Host intents have been installed correctly" )
+
+        case6_result = Ping_Result
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case6_result,
+            onpass="Host intent addition and Pingall Test successful",
+            onfail="Host intent addition and Pingall Test NOT successful" )
+
+    def CASE7( self, main ):
+
+        from sts.topology.teston_topology import TestONTopology
+        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+        link_sleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
+
+        main.log.report(
+            "This testscase is killing a link to ensure that \
+            link discovery is consistent" )
+        main.log.report( "__________________________________" )
+        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.ONOScli1.topology()
+        topology_result = main.ONOSbench.get_topology( topology_output )
+        activeSwitches = topology_result[ 'devices' ]
+        links = topology_result[ '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.ONOScli2.topology()
+        Link_Down = main.ONOSbench.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.ONOScli2.topology()
+        Link_Up = main.ONOSbench.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" )
+        main.case(
+            "Testing Mininet topology with the topology of \
+            multi instances ONOS" )
+        main.step( "Collecting topology information from ONOS" )
+        devices1 = main.ONOScli1.devices()
+        devices2 = main.ONOScli2.devices()
+        devices3 = main.ONOScli3.devices()
+        hosts1 = main.ONOScli1.hosts()
+        hosts2 = main.ONOScli2.hosts()
+        hosts3 = main.ONOScli3.hosts()
+        ports1 = main.ONOScli1.ports()
+        ports2 = main.ONOScli2.ports()
+        ports3 = main.ONOScli3.ports()
+        links1 = main.ONOScli1.links()
+        links2 = main.ONOScli2.links()
+        links3 = main.ONOScli3.links()
+
+        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" )
+
+        switches_results1 = main.Mininet1.compare_switches(
+            MNTopo,
+            json.loads( devices1 ) )
+        print "switches_Result1 = ", switches_results1
+        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" )
+
+        switches_results3 = main.Mininet1.compare_switches(
+            MNTopo,
+            json.loads( devices3 ) )
+        utilities.assert_equals( expect=main.TRUE, actual=switches_results3,
+                                 onpass="ONOS3 Switches view is correct",
+                                 onfail="ONOS3 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" )
+
+        ports_results3 =  main.Mininet1.compare_ports(
+                            MNTopo, json.loads( ports3 ) )
+        utilities.assert_equals( expect=main.TRUE, actual=ports_results3,
+                onpass="ONOS3 Ports view is correct",
+                onfail="ONOS3 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" )
+
+        links_results3 = main.Mininet1.compare_links(
+            MNTopo,
+            json.loads( links3 ) )
+        utilities.assert_equals( expect=main.TRUE, actual=links_results3,
+                                 onpass="ONOS2 Links view is correct",
+                                 onfail="ONOS2 Links view is incorrect" )
+
+        # topo_result = switches_results1 and switches_results2 and \
+        # switches_results3  and ports_results1 and ports_results2 and \
+        # ports_results3 and links_results1 and links_results2 and \
+        # links_results3
+
+        topo_result = switches_results1 and switches_results2 \
+                        and switches_results3 and links_results1 and \
+                        links_results2 and links_results3
+
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=topo_result and Link_Up and Link_Down,
+            onpass="Topology Check Test successful",
+            onfail="Topology Check Test NOT successful" )
+
+    def CASE8( self ):
+        """
+        Intent removal
+        """
+        main.log.report(
+            "This testcase removes host any previously added intents" )
+        main.log.report( "__________________________________" )
+        main.log.info( "Removing any previously installed intents" )
+        main.case( "Removing intents" )
+        main.step( "Obtain the intent id's" )
+        intent_result = main.ONOScli1.intents( json_format=False )
+
+        intent_linewise = intent_result.split( "\n" )
+        intentList = []
+        for line in intent_linewise:
+            if line.startswith( "id=" ):
+                intentList.append( line )
+
+        intentids = []
+        for line in intentList:
+            intentids.append( line.split( "," )[ 0 ].split( "=" )[ 1 ] )
+        for id in intentids:
+            main.log.info( "id = " + id )
+
+        main.step(
+            "Iterate through the intentids list and remove each intent" )
+        for id in intentids:
+            main.ONOScli1.remove_intent( intent_id=id )
+
+        intent_result = main.ONOScli1.intents( json_format=False )
+        main.log.info( "intent_result = " + intent_result )
+        case8_result = main.TRUE
+
+        i = 8
+        Ping_Result = main.TRUE
+        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.TRUE:
+                i = 19
+                Ping_Result = main.TRUE
+            elif ping == main.FALSE:
+                i += 1
+                Ping_Result = main.FALSE
+            else:
+                main.log.info( "Unknown error" )
+                Ping_Result = main.ERROR
+
+        # Note: If the ping result failed, that means the intents have been
+        # withdrawn correctly.
+        if Ping_Result == main.TRUE:
+            main.log.report( "Host intents have not been withdrawn correctly" )
+            # main.cleanup()
+            # main.exit()
+        if Ping_Result == main.FALSE:
+            main.log.report( "Host intents have been withdrawn correctly" )
+
+        case8_result = case8_result and Ping_Result
+
+        if case8_result == main.FALSE:
+            main.log.report( "Intent removal successful" )
+        else:
+            main.log.report( "Intent removal failed" )
+
+        utilities.assert_equals( expect=main.FALSE, actual=case8_result,
+                                 onpass="Intent removal test failed",
+                                 onfail="Intent removal test successful" )
+
+    def CASE9( self ):
+        """
+        This test case adds point intents. Make sure you run test case 8
+        which is host intent removal before executing this test case.
+        Else the host intents flows will persist on switches and the ping
+         would work even if there is some issue with the point intent's flows
+        """
+        main.log.report(
+            "This testcase adds point intents and then does pingall" )
+        main.log.report( "__________________________________" )
+        main.log.info( "Adding point intents" )
+        main.case(
+                    "Adding bidirectional point for mn hosts \
+                    h8-h18 h9-h19 h10-h20 h11-h21 h12-h22 h13-h23 \
+                    h14-h24 h15-h25 h16-h26 h17-h27" )
+
+        main.step( "Add point-to-point intents for mininet hosts \
+                   h8 and h18 or ONOS hosts h8 and h12" )
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000003008/1",
+            "of:0000000000006018/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006018/1",
+            "of:0000000000003008/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003009/1",
+            "of:0000000000006019/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006019/1",
+            "of:0000000000003009/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003010/1",
+            "of:0000000000006020/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006020/1",
+            "of:0000000000003010/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003011/1",
+            "of:0000000000006021/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006021/1",
+            "of:0000000000003011/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003012/1",
+            "of:0000000000006022/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006022/1",
+            "of:0000000000003012/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003013/1",
+            "of:0000000000006023/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006023/1",
+            "of:0000000000003013/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003014/1",
+            "of:0000000000006024/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006024/1",
+            "of:0000000000003014/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003015/1",
+            "of:0000000000006025/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006025/1",
+            "of:0000000000003015/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003016/1",
+            "of:0000000000006026/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006026/1",
+            "of:0000000000003016/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.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.ONOScli1.add_point_intent(
+            "of:0000000000003017/1",
+            "of:0000000000006027/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        ptp_intent_result = main.ONOScli1.add_point_intent(
+            "of:0000000000006027/1",
+            "of:0000000000003017/1" )
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli1.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( get_intent_result )
+
+        print("___________________________________________________________" )
+
+        flowHandle = main.ONOScli1.flows()
+        main.log.info( "flows :" + flowHandle )
+
+        count = 1
+        i = 8
+        Ping_Result = main.TRUE
+        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 between h" +
+                                 str( i ) +
+                                 " and h" +
+                                 str( i +
+                                      10 ) +
+                                 "have failed" )
+                i = 19
+                Ping_Result = main.FALSE
+            elif ping == main.TRUE:
+                main.log.info( "Ping test between h" +
+                               str( i ) +
+                               " and h" +
+                               str( i +
+                                    10 ) +
+                               "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(
+                "Ping all test after Point intents addition failed. \
+                Cleaning up" )
+            # main.cleanup()
+            # main.exit()
+        if Ping_Result == main.TRUE:
+            main.log.report(
+                "Ping all test after Point intents addition successful" )
+
+        case8_result = Ping_Result
+        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 CASE31( self ):
+        """
+            This test case adds point intent related to SDN-IP
+            matching on ICMP ( ethertype=IPV4, ipProto=1 )
+        """
+        import json
+
+        main.log.report(
+            '''This test case adds point intent related to SDN-IP
+            matching on ICMP''' )
+        main.case(
+            '''Adding bidirectional point intent related to SDN-IP
+            matching on ICMP''' )
+        main.step( "Adding bidirectional point intent" )
+        # add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32
+        # --ethType=IPV4 --ipProto=1  of:0000000000003008/1
+        # of:0000000000006018/1
+
+        hosts_json = json.loads( main.ONOScli1.hosts() )
+        for i in range( 8, 11 ):
+            main.log.info(
+                "Adding point 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()
+            host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
+            host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
+            for host in hosts_json:
+                if host[ 'id' ] == host1_id:
+                    ip1 = host[ 'ips' ][ 0 ]
+                    ip1 = str( ip1 + "/32" )
+                    device1 = host[ 'location' ][ 'device' ]
+                    device1 = str( device1 + "/1" )
+                elif host[ 'id' ] == host2_id:
+                    ip2 = str( host[ 'ips' ][ 0 ] ) + "/32"
+                    device2 = host[ 'location' ][ "device" ]
+                    device2 = str( device2 + "/1" )
+
+            p_intent_result1 = main.ONOScli1.add_point_intent(
+                ingress_device=device1,
+                egress_device=device2,
+                ipSrc=ip1,
+                ipDst=ip2,
+                ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+                ipProto=main.params[ 'SDNIP' ][ 'icmpProto' ] )
+
+            get_intent_result = main.ONOScli1.intents( json_format=False )
+            main.log.info( get_intent_result )
+
+            p_intent_result2 = main.ONOScli1.add_point_intent(
+                ingress_device=device2,
+                egress_device=device1,
+                ipSrc=ip2,
+                ipDst=ip1,
+                ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+                ipProto=main.params[ 'SDNIP' ][ 'icmpProto' ] )
+
+            get_intent_result = main.ONOScli1.intents( json_format=False )
+            main.log.info( get_intent_result )
+            if ( p_intent_result1 and p_intent_result2 ) == main.TRUE:
+                # get_intent_result = main.ONOScli1.intents()
+                # main.log.info( get_intent_result )
+                main.log.info(
+                    '''Point intent related to SDN-IP matching on ICMP install
+                    successful''' )
+
+        time.sleep( 15 )
+        get_intent_result = main.ONOScli1.intents( json_format=False )
+        main.log.info( "intents = " + get_intent_result )
+        get_flows_result = main.ONOScli1.flows()
+        main.log.info( "flows = " + get_flows_result )
+
+        count = 1
+        i = 8
+        Ping_Result = main.TRUE
+        while i < 11:
+            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 < 3:
+                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 between h" +
+                                 str( i ) +
+                                 " and h" +
+                                 str( i +
+                                      10 ) +
+                                 "have failed" )
+                i = 19
+                Ping_Result = main.FALSE
+            elif ping == main.TRUE:
+                main.log.info( "Ping test between h" +
+                               str( i ) +
+                               " and h" +
+                               str( i +
+                                    10 ) +
+                               "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(
+                "Ping test after Point intents related to SDN-IP \
+                matching on ICMP failed." )
+            # main.cleanup()
+            # main.exit()
+        if Ping_Result == main.TRUE:
+            main.log.report(
+                "Ping all test after Point intents related to SDN-IP \
+                matching on ICMP successful" )
+
+        case31_result = Ping_Result and p_intent_result1 and p_intent_result2
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case31_result,
+            onpass="Point intent related to SDN-IP matching on ICMP and \
+                    ping test successful",
+            onfail="Point intent related to SDN-IP matching on ICMP and \
+                    ping test failed" )
+
+    def CASE32( self ):
+        '''
+            This test case adds point intent related to SDN-IP matching on TCP
+            ( ethertype=IPV4, ipProto=6, DefaultPort for iperf=5001 )
+            Note: Although BGP port is 179, we are using 5001 because iperf is
+            used for verifying and iperf's default port is 5001
+        '''
+        import json
+
+        main.log.report( '''This test case adds point intent related
+                         to SDN-IP matching on TCP''' )
+        main.case( '''Adding bidirectional point intent related to SDN-IP
+                    matching on TCP''' )
+        main.step( "Adding bidirectional point intent" )
+
+        """
+        add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32
+                    --ethType=IPV4 --ipProto=6 --tcpDst=5001
+                    of:0000000000003008/1 of:0000000000006018/1
+
+        add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32
+                    --ethType=IPV4 --ipProto=6 --tcpDst=5001
+                    of:0000000000006018/1 of:0000000000003008/1
+
+        add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32
+                    --ethType=IPV4 --ipProto=6 --tcpSrc=5001
+                    of:0000000000003008/1 of:0000000000006018/1
+
+        add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32
+                    --ethType=IPV4 --ipProto=6 --tcpSrc=5001
+                    of:0000000000006018/1 of:0000000000003008/1
+
+        """
+        hosts_json = json.loads( main.ONOScli1.hosts() )
+        for i in range( 8, 9 ):
+            main.log.info(
+                "Adding point 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()
+            host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
+            host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
+            for host in hosts_json:
+                if host[ 'id' ] == host1_id:
+                    ip1 = host[ 'ips' ][ 0 ]
+                    ip1 = str( ip1 + "/32" )
+                    device1 = host[ 'location' ][ 'device' ]
+                    device1 = str( device1 + "/1" )
+                elif host[ 'id' ] == host2_id:
+                    ip2 = str( host[ 'ips' ][ 0 ] ) + "/32"
+                    device2 = host[ 'location' ][ "device" ]
+                    device2 = str( device2 + "/1" )
+
+            p_intent_result1 = main.ONOScli1.add_point_intent(
+                ingress_device=device1,
+                egress_device=device2,
+                ipSrc=ip1,
+                ipDst=ip2,
+                ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+                ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+                tcpDst=main.params[ 'SDNIP' ][ 'dstPort' ] )
+            p_intent_result2 = main.ONOScli1.add_point_intent(
+                ingress_device=device2,
+                egress_device=device1,
+                ipSrc=ip2,
+                ipDst=ip1,
+                ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+                ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+                tcpDst=main.params[ 'SDNIP' ][ 'dstPort' ] )
+
+            p_intent_result3 = main.ONOScli1.add_point_intent(
+                ingress_device=device1,
+                egress_device=device2,
+                ipSrc=ip1,
+                ipDst=ip2,
+                ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+                ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+                tcpSrc=main.params[ 'SDNIP' ][ 'srcPort' ] )
+            p_intent_result4 = main.ONOScli1.add_point_intent(
+                ingress_device=device2,
+                egress_device=device1,
+                ipSrc=ip2,
+                ipDst=ip1,
+                ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+                ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+                tcpSrc=main.params[ 'SDNIP' ][ 'srcPort' ] )
+
+            p_intent_result = p_intent_result1 and p_intent_result2 and \
+                                p_intent_result3 and p_intent_result4
+            if p_intent_result == main.TRUE:
+                get_intent_result = main.ONOScli1.intents( json_format=False )
+                main.log.info( get_intent_result )
+                main.log.info( '''Point intent related to SDN-IP matching
+                                on TCP install successful''' )
+
+        iperf_result = main.Mininet1.iperf( 'h8', 'h18' )
+        if iperf_result == main.TRUE:
+            main.log.report( "iperf test successful" )
+        else:
+            main.log.report( "iperf test failed" )
+
+        case32_result = p_intent_result and iperf_result
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case32_result,
+            onpass="Ping all test after Point intents addition related to \
+                    SDN-IP on TCP match successful",
+            onfail="Ping all test after Point intents addition related to \
+                    SDN-IP on TCP match failed" )
+
+    def CASE33( self ):
+        """
+            This test case adds multipoint to singlepoint  intent related
+            to SDN-IP matching on destination ip and the action is to
+            rewrite the mac address.
+            Here the mac address to be rewritten is the mac address
+            of the egress device
+        """
+        import json
+        import time
+
+        main.log.report( "This test case adds multipoint to singlepoint intent\
+                         related to SDN-IP matching on destination ip and\
+                         rewrite mac address action" )
+        main.case( "Adding multipoint to singlepoint intent related to SDN-IP\
+                    matching on destination ip" )
+        main.step( "Adding bidirectional multipoint to singlepoint intent" )
+        """
+        add-multi-to-single-intent --ipDst=10.0.3.0/24
+            --setEthDst=00:00:00:00:00:12
+            of:0000000000003008/1 0000000000003009/1 of:0000000000006018/1
+
+        add-multi-to-single-intent --ipDst=10.0.1.0/24
+            --setEthDst=00:00:00:00:00:08
+            of:0000000000006018/1 0000000000003009/1 of:0000000000003008/1
+        """
+        main.case( "Installing multipoint to single point intent with\
+                   rewrite mac address" )
+        main.step( "Uninstalling proxy arp app" )
+        # Unistall onos-app-proxyarp app to disable reactive forwarding
+        appUninstall_result1 = main.ONOScli1.feature_uninstall(
+            "onos-app-proxyarp" )
+        appUninstall_result2 = main.ONOScli2.feature_uninstall(
+            "onos-app-proxyarp" )
+        appUninstall_result3 = main.ONOScli3.feature_uninstall(
+            "onos-app-proxyarp" )
+        main.log.info( "onos-app-proxyarp uninstalled" )
+
+        main.step( "Changing ipaddress of hosts h8,h9 and h18" )
+        main.Mininet1.changeIP(
+            host='h8',
+            intf='h8-eth0',
+            newIP='10.0.1.1',
+            newNetmask='255.255.255.0' )
+        main.Mininet1.changeIP(
+            host='h9',
+            intf='h9-eth0',
+            newIP='10.0.2.1',
+            newNetmask='255.255.255.0' )
+        main.Mininet1.changeIP(
+            host='h10',
+            intf='h10-eth0',
+            newIP='10.0.3.1',
+            newNetmask='255.255.255.0' )
+
+        main.step( "Changing default gateway of hosts h8,h9 and h18" )
+        main.Mininet1.changeDefaultGateway( host='h8', newGW='10.0.1.254' )
+        main.Mininet1.changeDefaultGateway( host='h9', newGW='10.0.2.254' )
+        main.Mininet1.changeDefaultGateway( host='h10', newGW='10.0.3.254' )
+
+        main.step( "Assigning random mac address to the default gateways\
+                    since proxyarp app is uninstalled" )
+        main.Mininet1.addStaticMACAddress(
+            host='h8',
+            GW='10.0.1.254',
+            macaddr='00:00:00:00:11:11' )
+        main.Mininet1.addStaticMACAddress(
+            host='h9',
+            GW='10.0.2.254',
+            macaddr='00:00:00:00:22:22' )
+        main.Mininet1.addStaticMACAddress(
+            host='h10',
+            GW='10.0.3.254',
+            macaddr='00:00:00:00:33:33' )
+
+        main.step( "Verify static gateway and MAC address assignment" )
+        main.Mininet1.verifyStaticGWandMAC( host='h8' )
+        main.Mininet1.verifyStaticGWandMAC( host='h9' )
+        main.Mininet1.verifyStaticGWandMAC( host='h10' )
+
+        main.step( "Adding multipoint to singlepoint intent" )
+        p_intent_result1 = main.ONOScli1.add_multipoint_to_singlepoint_intent(
+            ingress_device1=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
+            ingress_device2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+            egress_device=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
+            ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip1' ],
+            setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac1' ] )
+
+        p_intent_result2 = main.ONOScli1.add_multipoint_to_singlepoint_intent(
+            ingress_device1=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
+            ingress_device2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+            egress_device=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
+            ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip2' ],
+            setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac2' ] )
+
+        get_intent_result = main.ONOScli1.intents( json_format=False )
+        main.log.info( "intents = " + get_intent_result )
+
+        time.sleep( 10 )
+        get_flows_result = main.ONOScli1.flows( json_format=False )
+        main.log.info( "flows = " + get_flows_result )
+
+        count = 1
+        i = 8
+        Ping_Result = main.TRUE
+
+        main.log.info( "\n\nh" + str( i ) + " is Pinging h" + str( i + 2 ) )
+        ping = main.Mininet1.pingHost(
+            src="h" + str( i ), target="h" + str( i + 2 ) )
+        if ping == main.FALSE and count < 3:
+            count += 1
+            Ping_Result = main.FALSE
+            main.log.report( "Ping between h" +
+                             str( i ) +
+                             " and h" +
+                             str( i +
+                                  2 ) +
+                             " failed. Making attempt number " +
+                             str( count ) +
+                             " in 2 seconds" )
+            time.sleep( 2 )
+        elif ping == main.FALSE:
+            main.log.report( "All ping attempts between h" +
+                             str( i ) +
+                             " and h" +
+                             str( i +
+                                  10 ) +
+                             "have failed" )
+            Ping_Result = main.FALSE
+        elif ping == main.TRUE:
+            main.log.info( "Ping test between h" +
+                           str( i ) +
+                           " and h" +
+                           str( i +
+                                2 ) +
+                           "passed!" )
+            Ping_Result = main.TRUE
+        else:
+            main.log.info( "Unknown error" )
+            Ping_Result = main.ERROR
+
+        if Ping_Result == main.FALSE:
+            main.log.report( "Ping test failed." )
+            # main.cleanup()
+            # main.exit()
+        if Ping_Result == main.TRUE:
+            main.log.report( "Ping all successful" )
+
+        p_intent_result = p_intent_result1 and p_intent_result2
+        if p_intent_result == main.TRUE:
+            main.log.info( "Multi point intent with rewrite mac address\
+                            installation successful" )
+        else:
+            main.log.info( "Multi point intent with rewrite mac address\
+                            installation failed" )
+
+        case33_result = p_intent_result and Ping_Result
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case33_result,
+            onpass="Ping all test after multipoint to single point intent \
+                    addition with rewrite mac address successful",
+            onfail="Ping all test after multipoint to single point intent \
+                    addition with rewrite mac address failed" )
+
diff --git a/TestON/tests/MultiProd13/MultiProd13.params b/TestON/tests/MultiProd13/MultiProd13.params
index 8bf1600..6e5c85e 100755
--- a/TestON/tests/MultiProd13/MultiProd13.params
+++ b/TestON/tests/MultiProd13/MultiProd13.params
@@ -1,6 +1,6 @@
 <PARAMS>
     
-    <testcases>1,4,10,5,6,7,8,6,8,9,31,32,8,33</testcases>    
+    <testcases>1,4,10,5,6,7,8,6,8,9,8,31,32,8,33,8</testcases>    
 
     #Environment variables
     <ENV>
diff --git a/TestON/tests/MultiProd13/MultiProd13.py b/TestON/tests/MultiProd13/MultiProd13.py
index cbf27a4..d3ed757 100644
--- a/TestON/tests/MultiProd13/MultiProd13.py
+++ b/TestON/tests/MultiProd13/MultiProd13.py
@@ -11,8 +11,7 @@
 
 time.sleep( 1 )
 
-
-class MultiProd13:
+class MultiProd:
 
     def __init__( self ):
         self.default = ''
@@ -53,8 +52,8 @@
         main.step( "Removing raft logs before a clen installation of ONOS" )
         removeLogResult = main.ONOSbench.onosRemoveRaftLogs()
 
-        main.step( "Git checkout and pull master and get version" )
-        main.ONOSbench.gitCheckout( "master" )
+        main.step( "Git checkout, pull and get version" )
+        #main.ONOSbench.gitCheckout( "master" )
         gitPullResult = main.ONOSbench.gitPull()
         print "git_pull_result = ", gitPullResult
         versionResult = main.ONOSbench.getVersion( report=True )
@@ -514,7 +513,6 @@
             tmpResult = main.ONOScli1.addHostIntent( host1Id, host2Id )
 
         flowHandle = main.ONOScli1.flows()
-        # print "flowHandle = ", flowHandle
         main.log.info( "flows:" + flowHandle )
 
         count = 1
@@ -857,7 +855,7 @@
         Intent removal
         """
         main.log.report(
-            "This testcase removes host any previously added intents" )
+            "This testcase removes any previously added intents" )
         main.log.report( "__________________________________" )
         main.log.info( "Removing any previously installed intents" )
         main.case( "Removing intents" )
@@ -1424,9 +1422,13 @@
             if pIntentResult == main.TRUE:
                 getIntentResult = main.ONOScli1.intents( jsonFormat=False )
                 main.log.info( getIntentResult )
-                main.log.info(
+                main.log.report(
                     "Point intent related to SDN-IP matching" +
                     " on TCP install successful" )
+            else:
+                main.log.report(
+                    "Point intent related to SDN-IP matching" +
+                    " on TCP install failed" )
 
         iperfResult = main.Mininet1.iperf( 'h8', 'h18' )
         if iperfResult == main.TRUE:
diff --git a/TestON/tests/OpticalFunc13/OpticalFunc13.params b/TestON/tests/OpticalFunc13/OpticalFunc13.params
new file mode 100755
index 0000000..173d48b
--- /dev/null
+++ b/TestON/tests/OpticalFunc13/OpticalFunc13.params
@@ -0,0 +1,47 @@
+<PARAMS>
+    
+    <testcases>1,21,22,23</testcases>
+
+    #Environment variables
+    <ENV>
+        <cellName>driver_test</cellName>
+    </ENV>
+
+    <CTRL>
+        <ip1>10.128.20.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>
+
+    <OPTICAL>
+        <jsonfile> /home/admin/ONOS/tools/test/topos/oe-nonlinear-4.json </jsonfile>
+    </OPTICAL>    
+
+</PARAMS>
diff --git a/TestON/tests/OpticalFunc13/OpticalFunc13.py b/TestON/tests/OpticalFunc13/OpticalFunc13.py
new file mode 100755
index 0000000..7ddd532
--- /dev/null
+++ b/TestON/tests/OpticalFunc13/OpticalFunc13.py
@@ -0,0 +1,248 @@
+
+#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 OpticalFunc13:
+    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()
+        main.log.report(main.ONOSbench.get_version())
+        if git_pull_result == 1:
+            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 CASE21(self, main):
+        import time
+        '''
+            On ONOS bench, run this command: ./~/ONOS/tools/test/bin/onos-topo-cfg
+            which starts the rest and copies the links json file to the onos instance
+            Note that in case of Packet Optical, the links are not learnt from the topology, instead the links are learnt 
+            from the json config file
+        '''
+        main.log.report("This testcase starts the packet layer topology and REST")
+        main.log.report("_____________________________________________")
+        sart_console_result = main.LincOE1.start_console()
+        optical_mn_script = main.LincOE2.run_optical_mn_script()
+        onos_topo_cfg_result = main.ONOSbench.run_onos_topo_cfg(instance_name = main.params['CTRL']['ip1'], json_file = main.params['OPTICAL']['jsonfile'])
+         
+
+
+    def CASE22(self, main):
+        '''
+            Curretly we use, 4 linear switch optical topology and 2 packet layer mininet switches each with one host.
+             Therefore, the roadmCount variable = 4, packetLayerSWCount variable = 2, hostCount =2
+            and this is hardcoded in the testcase. If the topology changes, these hardcoded values need to be changed
+        '''
+
+        main.log.report("This testcase compares the optical+packet topology against what is expected")
+        main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+        devices_result = main.ONOS2.devices(json_format = False)
+
+        print "devices_result = ", devices_result
+        devices_linewise = devices_result.split("\n")
+        devices_linewise = devices_linewise[1:-1]
+        roadmCount = 0
+        packetLayerSWCount = 0
+        for line in devices_linewise:
+            components = line.split(",")
+            availability = components[1].split("=")[1]
+            type = components[3].split("=")[1]
+            if availability == 'true' and type == 'ROADM':
+                roadmCount += 1
+            elif availability == 'true' and type =='SWITCH':
+                packetLayerSWCount += 1
+        if roadmCount == 4:
+            print "Number of Optical Switches = %d and is correctly detected" %roadmCount
+            main.log.info ("Number of Optical Switches = " +str(roadmCount) +" and is correctly detected")
+            opticalSW_result = main.TRUE
+        else:
+            print "Number of Optical Switches = %d and is wrong" %roadCount
+            main.log.info ("Number of Optical Switches = " +str(roadmCount) +" and is wrong")
+            opticalSW_result = main.FALSE
+
+        if packetLayerSWCount == 2:
+            print "Number of Packet layer or mininet Switches = %d and is correctly detected" %packetLayerSWCount
+            main.log.info("Number of Packet layer or mininet Switches = " +str(packetLayerSWCount) + " and is correctly detected")
+            packetSW_result = main.TRUE
+        else:
+            print "Number of Packet layer or mininet Switches = %d and is wrong" %packetLayerSWCount
+            main.log.info("Number of Packet layer or mininet Switches = " +str(packetLayerSWCount) + " and is wrong")
+            packetSW_result = main.FALSE
+        print "_________________________________"
+        
+        links_result = main.ONOS2.links(json_format = False)
+        print "links_result = ", links_result
+        print "_________________________________"
+        
+
+
+        #Discover hosts using pingall
+        pingall_result = main.LincOE2.pingall()    
+    
+        hosts_result = main.ONOS2.hosts(json_format = False)
+        print "hosts_result = ", hosts_result   
+        print "_________________________________"
+        hosts_linewise = hosts_result.split("\n")
+        hosts_linewise = hosts_linewise[1:-1]
+        hostCount = 0
+        for line in hosts_linewise:
+            hostid = line.split(",")[0].split("=")[1]
+            hostCount +=1
+        if hostCount ==2:
+            print "Number of hosts = %d and is correctly detected" %hostCount
+            main.log.info("Number of hosts = " + str(hostCount) +" and is correctly detected")
+            hostDiscovery = main.TRUE
+        else:
+            print "Number of hosts = %d and is wrong" %hostCount
+            main.log.info("Number of hosts = " + str(hostCount) +" and is wrong")
+            hostDiscovery = main.FALSE
+        
+        case22_result = opticalSW_result and packetSW_result and hostDiscovery
+        utilities.assert_equals(expect=main.TRUE, actual=case22_result,
+                onpass="Packet optical topology discovery successful",
+                onfail="Packet optical topology discovery failed")
+
+    def CASE23(self, main):
+        import time
+        '''
+            Add bidirectional point intents between 2 packet layer(mininet) devices and 
+            ping mininet hosts
+        '''
+        main.log.report("This testcase adds bidirectional point intents between 2 packet layer(mininet) devices and ping mininet hosts")
+        ptp_intent_result = main.ONOS2.add_point_intent("of:0000ffffffff0001", 1, "of:0000ffffffff0002", 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:0000ffffffff0002", 1, "of:0000ffffffff0001", 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)
+
+        time.sleep(10)
+        flowHandle = main.ONOS2.flows()
+        #print "flowHandle = ", flowHandle
+        main.log.info("flows :" + flowHandle)
+        intentHandle = main.ONOS2.intents()        
+        main.log.info("intents :" + intentHandle)        
+ 
+        Ping_Result = main.TRUE
+        count = 1
+        main.log.info("\n\nh1 is Pinging h2")
+        ping = main.LincOE2.pingHostOptical(src="h1", target="h2")
+        #ping = main.LincOE2.pinghost()
+        if ping == main.FALSE and count<5:
+            count+=1
+            Ping_Result = main.FALSE
+            main.log.report("Ping between h1 and h2  failed. Making attempt number "+str(count) + " in 2 seconds")
+            time.sleep(2)
+            ping = main.LincOE2.pingHostOptical(src="h1", target="h2")
+            #ping = main.LincOE2.pinghost()
+        elif ping==main.FALSE:
+            main.log.report("All ping attempts between h1 and h2 have failed")
+            Ping_Result = main.FALSE
+        elif ping==main.TRUE:
+            main.log.info("Ping test between h1 and h2 passed!")
+            Ping_Result = main.TRUE
+        else:
+            main.log.info("Unknown error")
+            Ping_Result = main.ERROR
+        
+        if Ping_Result==main.FALSE:
+            main.log.report("Point intents for packet optical have not ben installed correctly. Cleaning up")
+        if Ping_Result==main.TRUE:
+            main.log.report("Point Intents for packet optical have been installed correctly")
+
+        case23_result = Ping_Result
+        utilities.assert_equals(expect=main.TRUE, actual=case23_result,
+                onpass="Point intents addition for packet optical and Pingall Test successful",
+                onfail="Point intents addition for packet optical and Pingall Test NOT successful")
+
+
diff --git a/TestON/tests/OpticalFunc13/OpticalFunc13.topo b/TestON/tests/OpticalFunc13/OpticalFunc13.topo
new file mode 100755
index 0000000..a3d6cfd
--- /dev/null
+++ b/TestON/tests/OpticalFunc13/OpticalFunc13.topo
@@ -0,0 +1,94 @@
+<TOPOLOGY>
+    <COMPONENT>
+
+        <ONOSbench>
+            <host>10.128.10.11</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosDriver</type>
+            <connect_order>1</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOSbench>
+
+        <ONOS1>
+            <host>10.128.10.11</host>
+            <user>sdn</user>
+            <password>sdn</password>
+            <type>OnosDriver</type>
+            <connect_order>2</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOS1>
+
+        <ONOS2>
+            <host>10.128.10.11</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosCliDriver</type>
+            <connect_order>3</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOS2>
+
+        <Mininet1>
+            <host>10.128.10.11</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=OpenFlow13 </arg3>
+                <controller> remote </controller>
+            </COMPONENTS>
+        </Mininet1>
+
+        <Mininet2>
+            <host>10.128.10.11</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=OpenFlow13 </arg3>
+                <controller> remote </controller>
+            </COMPONENTS>
+        </Mininet2>
+
+         <LincOE1>
+            <host>10.128.20.30</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>LincOEDriver</type>
+            <connect_order>6</connect_order>
+            <COMPONENTS>
+                <arg1> </arg1>
+            </COMPONENTS>
+        </LincOE1>
+
+         <LincOE2>
+            <host>10.128.20.30</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>RemoteMininetDriver</type>
+            <connect_order>7</connect_order>
+            <COMPONENTS>
+                <arg1> sudo python /home/admin/optical.py </arg1>
+                <arg2> </arg2>
+            </COMPONENTS>
+        </LincOE2>
+
+        <LincOE3>
+            <host>10.128.20.30</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>RemoteMininetDriver</type>
+            <connect_order>8</connect_order>
+        </LincOE3>
+ 
+    
+    </COMPONENT>
+</TOPOLOGY>
diff --git a/TestON/tests/OpticalFunc13/__init__.py b/TestON/tests/OpticalFunc13/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/TestON/tests/OpticalFunc13/__init__.py
diff --git a/TestON/tests/ProdFunc/ProdFunc.params b/TestON/tests/ProdFunc/ProdFunc.params
index 2d1f421..1189301 100755
--- a/TestON/tests/ProdFunc/ProdFunc.params
+++ b/TestON/tests/ProdFunc/ProdFunc.params
@@ -1,6 +1,6 @@
 <PARAMS>
     
-    <testcases>1,4,9</testcases>
+    <testcases>1,4,10,5,6,7,8,9,2,8,20,21,22,10,23,24</testcases>
     #Environment variables
     <ENV>
         <cellName>driver_test</cellName>
diff --git a/TestON/tests/ProdFunc/ProdFunc.py b/TestON/tests/ProdFunc/ProdFunc.py
index b2797f3..5e31df3 100755
--- a/TestON/tests/ProdFunc/ProdFunc.py
+++ b/TestON/tests/ProdFunc/ProdFunc.py
@@ -43,8 +43,8 @@
         main.step( "Removing raft logs before a clen installation of ONOS" )
         main.ONOSbench.onosRemoveRaftLogs()
 
-        main.step( "Git checkout and pull master and get version" )
-        main.ONOSbench.gitCheckout( "master" )
+        main.step( "Git checkout and get version" )
+        #main.ONOSbench.gitCheckout( "master" )
         gitPullResult = main.ONOSbench.gitPull()
         main.log.info( "git_pull_result = " + gitPullResult )
         main.ONOSbench.getVersion( report=True )
diff --git a/TestON/tests/ProdFunc/ProdFunc.py.fixed b/TestON/tests/ProdFunc/ProdFunc.py.fixed
new file mode 100644
index 0000000..6f4b72b
--- /dev/null
+++ b/TestON/tests/ProdFunc/ProdFunc.py.fixed
@@ -0,0 +1,1395 @@
+
+# Testing the basic functionality of ONOS Next
+# For sanity and driver functionality excercises only.
+
+import time
+# import sys
+# import os
+# import re
+import json
+
+time.sleep( 1 )
+
+
+class ProdFunc:
+
+    def __init__( self ):
+        self.default = ''
+
+    def CASE1( self, main ):
+        """
+        Startup sequence:
+        cell <name>
+        onos-verify-cell
+        onos-remove-raft-log
+        git pull
+        mvn clean install
+        onos-package
+        onos-install -f
+        onos-wait-for-start
+        """
+        cellName = main.params[ 'ENV' ][ 'cellName' ]
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+        main.case( "Setting up test environment" )
+        main.log.report(
+            "This testcase is testing setting up test environment" )
+        main.log.report( "__________________________________" )
+
+        main.step( "Applying cell variable to environment" )
+        cellResult = main.ONOSbench.setCell( cellName )
+        verifyResult = main.ONOSbench.verifyCell()
+
+        main.step( "Removing raft logs before a clen installation of ONOS" )
+        main.ONOSbench.onosRemoveRaftLogs()
+
+        main.step( "Git checkout and pull master and get version" )
+        main.ONOSbench.gitCheckout( "master" )
+        gitPullResult = main.ONOSbench.gitPull()
+        main.log.info( "git_pull_result = " + gitPullResult )
+        main.ONOSbench.getVersion( report=True )
+
+        if gitPullResult == 1:
+            main.step( "Using mvn clean & install" )
+            main.ONOSbench.cleanInstall()
+        elif gitPullResult == 0:
+            main.log.report(
+                "Git Pull Failed, look into logs for detailed reason" )
+            main.cleanup()
+            main.exit()
+
+        main.step( "Creating ONOS package" )
+        packageResult = main.ONOSbench.onosPackage()
+
+        main.step( "Installing ONOS package" )
+        onosInstallResult = main.ONOSbench.onosInstall()
+        if onosInstallResult == main.TRUE:
+            main.log.report( "Installing ONOS package successful" )
+        else:
+            main.log.report( "Installing ONOS package failed" )
+
+        onos1Isup = main.ONOSbench.isup()
+        if onos1Isup == main.TRUE:
+            main.log.report( "ONOS instance is up and ready" )
+        else:
+            main.log.report( "ONOS instance may not be up" )
+
+        main.step( "Starting ONOS service" )
+        startResult = main.ONOSbench.onosStart( ONOS1Ip )
+
+        main.ONOS2.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
+
+        case1Result = ( packageResult and
+                        cellResult and verifyResult
+                        and onosInstallResult and
+                        onos1Isup and startResult )
+        utilities.assert_equals( expect=main.TRUE, actual=case1Result,
+                                onpass="Test startup successful",
+                                onfail="Test startup NOT successful" )
+
+    def CASE2( self, main ):
+        """
+        Switch Down
+        """
+        # NOTE: You should probably run a topology check after this
+        import time
+
+        main.case( "Switch down discovery" )
+        main.log.report( "This testcase is testing a switch down discovery" )
+        main.log.report( "__________________________________" )
+
+        switchSleep = int( main.params[ 'timers' ][ 'SwitchDiscovery' ] )
+
+        description = "Killing a switch to ensure it is discovered correctly"
+        main.log.report( description )
+        main.case( description )
+
+        # TODO: Make this switch parameterizable
+        main.step( "Kill s28 " )
+        main.log.report( "Deleting s28" )
+        # FIXME: use new dynamic topo functions
+        main.Mininet1.delSwitch( "s28" )
+        main.log.info(
+            "Waiting " +
+            str( switchSleep ) +
+            " seconds for switch down to be discovered" )
+        time.sleep( switchSleep )
+        # Peek at the deleted switch
+        device = main.ONOS2.getDevice( dpid="0028" )
+        print "device = ", device
+        if device[ u'available' ] == 'False':
+            case2Result = main.FALSE
+        else:
+            case2Result = main.TRUE
+        utilities.assert_equals( expect=main.TRUE, actual=case2Result,
+                                onpass="Switch down discovery successful",
+                                onfail="Switch down discovery failed" )
+
+    def CASE11( self, main ):
+        """
+        Cleanup sequence:
+        onos-service <nodeIp> stop
+        onos-uninstall
+
+        TODO: Define rest of cleanup
+
+        """
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+        main.case( "Cleaning up test environment" )
+
+        main.step( "Testing ONOS kill function" )
+        killResult = main.ONOSbench.onosKill( ONOS1Ip )
+
+        main.step( "Stopping ONOS service" )
+        stopResult = main.ONOSbench.onosStop( ONOS1Ip )
+
+        main.step( "Uninstalling ONOS service" )
+        uninstallResult = main.ONOSbench.onosUninstall()
+
+        case11Result = killResult and stopResult and uninstallResult
+        utilities.assert_equals( expect=main.TRUE, actual=case11Result,
+                                onpass="Cleanup successful",
+                                onfail="Cleanup failed" )
+
+    def CASE3( self, main ):
+        """
+        Test 'onos' command and its functionality in driver
+        """
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+        main.case( "Testing 'onos' command" )
+
+        main.step( "Sending command 'onos -w <onos-ip> system:name'" )
+        cmdstr1 = "system:name"
+        cmdResult1 = main.ONOSbench.onosCli( ONOS1Ip, cmdstr1 )
+        main.log.info( "onos command returned: " + cmdResult1 )
+
+        main.step( "Sending command 'onos -w <onos-ip> onos:topology'" )
+        cmdstr2 = "onos:topology"
+        cmdResult2 = main.ONOSbench.onosCli( ONOS1Ip, cmdstr2 )
+        main.log.info( "onos command returned: " + cmdResult2 )
+
+    def CASE20( self ):
+        """
+            Exit from mininet cli
+            reinstall ONOS
+        """
+        cellName = main.params[ 'ENV' ][ 'cellName' ]
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+        main.log.report( "This testcase exits the mininet cli and reinstalls\
+                        ONOS to switch over to Packet Optical topology" )
+        main.log.report( "_____________________________________________" )
+        main.case( "Disconnecting mininet and restarting ONOS" )
+        main.step( "Disconnecting mininet and restarting ONOS" )
+        mininetDisconnect = main.Mininet1.disconnect()
+
+        main.step( "Removing raft logs before a clen installation of ONOS" )
+        main.ONOSbench.onosRemoveRaftLogs()
+
+        main.step( "Applying cell variable to environment" )
+        cellResult = main.ONOSbench.setCell( cellName )
+        verifyResult = main.ONOSbench.verifyCell()
+
+        onosInstallResult = main.ONOSbench.onosInstall()
+        if onosInstallResult == main.TRUE:
+            main.log.report( "Installing ONOS package successful" )
+        else:
+            main.log.report( "Installing ONOS package failed" )
+
+        onos1Isup = main.ONOSbench.isup()
+        if onos1Isup == main.TRUE:
+            main.log.report( "ONOS instance is up and ready" )
+        else:
+            main.log.report( "ONOS instance may not be up" )
+
+        main.step( "Starting ONOS service" )
+        startResult = main.ONOSbench.onosStart( ONOS1Ip )
+
+        main.ONOS2.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
+        case20Result = mininetDisconnect and cellResult and verifyResult \
+            and onosInstallResult and onos1Isup and \
+            startResult
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case20Result,
+            onpass="Exiting functionality mininet topology and reinstalling \
+                    ONOS successful",
+            onfail="Exiting functionality mininet topology and reinstalling \
+                    ONOS failed" )
+
+    def CASE21( self, main ):
+        """
+            On ONOS bench, run this command:
+             ./~/ONOS/tools/test/bin/onos-topo-cfg
+            which starts the rest and copies the links
+            json file to the onos instance.
+            Note that in case of Packet Optical, the links are not learnt
+            from the topology, instead the links are learnt
+            from the json config file
+        """
+        main.log.report(
+            "This testcase starts the packet layer topology and REST" )
+        main.log.report( "_____________________________________________" )
+        main.case( "Starting LINC-OE and other components" )
+        main.step( "Starting LINC-OE and other components" )
+        startConsoleResult = main.LincOE1.startConsole()
+        opticalMnScript = main.LincOE2.runOpticalMnScript()
+        onosTopoCfgResult = main.ONOSbench.runOnosTopoCfg(
+            instanceName=main.params[ 'CTRL' ][ 'ip1' ],
+            jsonFile=main.params[ 'OPTICAL' ][ 'jsonfile' ] )
+
+        print "start_console_result =", startConsoleResult
+        print "optical_mn_script = ", opticalMnScript
+        print "onos_topo_cfg_result =", onosTopoCfgResult
+
+        case21Result = startConsoleResult and opticalMnScript and \
+            onosTopoCfgResult
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case21Result,
+            onpass="Packet optical topology spawned successsfully",
+            onfail="Packet optical topology spawning failed" )
+
+    def CASE22( self, main ):
+        """
+            Curretly we use, 4 linear switch optical topology and
+            2 packet layer mininet switches each with one host.
+            Therefore, the roadmCount variable = 4,
+            packetLayerSWCount variable = 2 and hostCount = 2
+            and this is hardcoded in the testcase. If the topology changes,
+            these hardcoded values need to be changed
+        """
+        main.log.report(
+            "This testcase compares the optical+packet topology against what\
+             is expected" )
+        main.case( "Topology comparision" )
+        main.step( "Topology comparision" )
+        main.ONOS3.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
+        devicesResult = main.ONOS3.devices( jsonFormat=False )
+
+        print "devices_result = ", devicesResult
+        devicesLinewise = devicesResult.split( "\n" )
+        devicesLinewise = devicesLinewise[ 1:-1 ]
+        roadmCount = 0
+        packetLayerSWCount = 0
+        for line in devicesLinewise:
+            components = line.split( "," )
+            availability = components[ 1 ].split( "=" )[ 1 ]
+            type = components[ 3 ].split( "=" )[ 1 ]
+            if availability == 'true' and type == 'ROADM':
+                roadmCount += 1
+            elif availability == 'true' and type == 'SWITCH':
+                packetLayerSWCount += 1
+        if roadmCount == 4:
+            print "Number of Optical Switches = %d and is \
+                    correctly detected" % roadmCount
+            main.log.info(
+                "Number of Optical Switches = " +
+                str( roadmCount ) +
+                " and is correctly detected" )
+            opticalSWResult = main.TRUE
+        else:
+            print "Number of Optical Switches = %d and is wrong" % roadmCount
+            main.log.info(
+                "Number of Optical Switches = " +
+                str( roadmCount ) +
+                " and is wrong" )
+            opticalSWResult = main.FALSE
+
+        if packetLayerSWCount == 2:
+            print "Number of Packet layer or mininet Switches = %d and \
+                    is correctly detected" % packetLayerSWCount
+            main.log.info(
+                "Number of Packet layer or mininet Switches = " +
+                str( packetLayerSWCount ) +
+                " and is correctly detected" )
+            packetSWResult = main.TRUE
+        else:
+            print "Number of Packet layer or mininet Switches = %d and \
+                    is wrong" % packetLayerSWCount
+            main.log.info(
+                "Number of Packet layer or mininet Switches = " +
+                str( packetLayerSWCount ) +
+                " and is wrong" )
+            packetSWResult = main.FALSE
+        print "_________________________________"
+
+        linksResult = main.ONOS3.links( jsonFormat=False )
+        print "links_result = ", linksResult
+        print "_________________________________"
+
+        # NOTE:Since only point intents are added, there is no
+        # requirement to discover the hosts
+        # Therfore, the below portion of the code is commented.
+        """
+        #Discover hosts using pingall
+        pingallResult = main.LincOE2.pingall()
+
+        hostsResult = main.ONOS3.hosts( jsonFormat=False )
+        main.log.info( "hosts_result = "+hostsResult )
+        main.log.info( "_________________________________" )
+        hostsLinewise = hostsResult.split( "\n" )
+        hostsLinewise = hostsLinewise[ 1:-1 ]
+        hostCount = 0
+        for line in hostsLinewise:
+            hostid = line.split( "," )[ 0 ].split( "=" )[ 1 ]
+            hostCount +=1
+        if hostCount ==2:
+            print "Number of hosts = %d and is correctly detected" %hostCount
+            main.log.info( "Number of hosts = " + str( hostCount ) +" and \
+                            is correctly detected" )
+            hostDiscovery = main.TRUE
+        else:
+            print "Number of hosts = %d and is wrong" %hostCount
+            main.log.info( "Number of hosts = " + str( hostCount ) +" and \
+                            is wrong" )
+            hostDiscovery = main.FALSE
+        """
+        case22Result = opticalSWResult and packetSWResult
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case22Result,
+            onpass="Packet optical topology discovery successful",
+            onfail="Packet optical topology discovery failed" )
+
+    def CASE23( self, main ):
+        import time
+        """
+            Add bidirectional point intents between 2 packet layer( mininet )
+            devices and
+            ping mininet hosts
+        """
+        main.log.report(
+            "This testcase adds bidirectional point intents between 2 \
+                packet layer( mininet ) devices and ping mininet hosts" )
+        main.case( "Topology comparision" )
+        main.step( "Adding point intents" )
+        ptpIntentResult = main.ONOS3.addPointIntent(
+            "of:0000ffffffff0001/1",
+            "of:0000ffffffff0002/1" )
+        if ptpIntentResult == main.TRUE:
+            main.ONOS3.intents( jsonFormat=False )
+            main.log.info( "Point to point intent install successful" )
+
+        ptpIntentResult = main.ONOS3.addPointIntent(
+            "of:0000ffffffff0002/1",
+            "of:0000ffffffff0001/1" )
+        if ptpIntentResult == main.TRUE:
+            main.ONOS3.intents( jsonFormat=False )
+            main.log.info( "Point to point intent install successful" )
+
+        time.sleep( 10 )
+        flowHandle = main.ONOS3.flows()
+        main.log.info( "flows :" + flowHandle )
+
+        # Sleep for 30 seconds to provide time for the intent state to change
+        time.sleep( 30 )
+        intentHandle = main.ONOS3.intents( jsonFormat=False )
+        main.log.info( "intents :" + intentHandle )
+
+        PingResult = main.TRUE
+        count = 1
+        main.log.info( "\n\nh1 is Pinging h2" )
+        ping = main.LincOE2.pingHostOptical( src="h1", target="h2" )
+        # ping = main.LincOE2.pinghost()
+        if ping == main.FALSE and count < 5:
+            count += 1
+            PingResult = main.FALSE
+            main.log.info(
+                "Ping between h1 and h2  failed. Making attempt number " +
+                str( count ) +
+                " in 2 seconds" )
+            time.sleep( 2 )
+        elif ping == main.FALSE:
+            main.log.info( "All ping attempts between h1 and h2 have failed" )
+            PingResult = main.FALSE
+        elif ping == main.TRUE:
+            main.log.info( "Ping test between h1 and h2 passed!" )
+            PingResult = main.TRUE
+        else:
+            main.log.info( "Unknown error" )
+            PingResult = main.ERROR
+
+        if PingResult == main.FALSE:
+            main.log.report(
+                "Point intents for packet optical have not ben installed\
+                correctly. Cleaning up" )
+        if PingResult == main.TRUE:
+            main.log.report(
+                "Point Intents for packet optical have been\
+                installed correctly" )
+
+        case23Result = PingResult
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case23Result,
+            onpass="Point intents addition for packet optical and\
+                    Pingall Test successful",
+            onfail="Point intents addition for packet optical and\
+                    Pingall Test NOT successful" )
+
+    def CASE24( self, main ):
+        import time
+        import json
+        """
+            Test Rerouting of Packet Optical by bringing a port down
+            ( port 22 ) of a switch( switchID=1 ), so that link
+            ( between switch1 port22 - switch4-port30 ) is inactive
+            and do a ping test. If rerouting is successful,
+            ping should pass. also check the flows
+        """
+        main.log.report(
+            "This testcase tests rerouting and pings mininet hosts" )
+        main.case( "Test rerouting and pings mininet hosts" )
+        main.step( "Bring a port down and verify the link state" )
+        main.LincOE1.portDown( swId="1", ptId="22" )
+        linksNonjson = main.ONOS3.links( jsonFormat=False )
+        main.log.info( "links = " + linksNonjson )
+
+        links = main.ONOS3.links()
+        main.log.info( "links = " + links )
+
+        linksResult = json.loads( links )
+        linksStateResult = main.FALSE
+        for item in linksResult:
+            if item[ 'src' ][ 'device' ] == "of:0000ffffffffff01" and item[
+                    'src' ][ 'port' ] == "22":
+                if item[ 'dst' ][ 'device' ] == "of:0000ffffffffff04" and item[
+                        'dst' ][ 'port' ] == "30":
+                    linksState = item[ 'state' ]
+                    if linksState == "INACTIVE":
+                        main.log.info(
+                            "Links state is inactive as expected due to one \
+                            of the ports being down" )
+                        main.log.report(
+                            "Links state is inactive as expected due to one \
+                            of the ports being down" )
+                        linksStateResult = main.TRUE
+                        break
+                    else:
+                        main.log.info(
+                            "Links state is not inactive as expected" )
+                        main.log.report(
+                            "Links state is not inactive as expected" )
+                        linksStateResult = main.FALSE
+
+        print "links_state_result = ", linksStateResult
+        time.sleep( 10 )
+        flowHandle = main.ONOS3.flows()
+        main.log.info( "flows :" + flowHandle )
+
+        main.step( "Verify Rerouting by a ping test" )
+        PingResult = main.TRUE
+        count = 1
+        main.log.info( "\n\nh1 is Pinging h2" )
+        ping = main.LincOE2.pingHostOptical( src="h1", target="h2" )
+        # ping = main.LincOE2.pinghost()
+        if ping == main.FALSE and count < 5:
+            count += 1
+            PingResult = main.FALSE
+            main.log.info(
+                "Ping between h1 and h2  failed. Making attempt number " +
+                str( count ) +
+                " in 2 seconds" )
+            time.sleep( 2 )
+        elif ping == main.FALSE:
+            main.log.info( "All ping attempts between h1 and h2 have failed" )
+            PingResult = main.FALSE
+        elif ping == main.TRUE:
+            main.log.info( "Ping test between h1 and h2 passed!" )
+            PingResult = main.TRUE
+        else:
+            main.log.info( "Unknown error" )
+            PingResult = main.ERROR
+
+        if PingResult == main.TRUE:
+            main.log.report( "Ping test successful " )
+        if PingResult == main.FALSE:
+            main.log.report( "Ping test failed" )
+
+        case24Result = PingResult and linksStateResult
+        utilities.assert_equals( expect=main.TRUE, actual=case24Result,
+                                onpass="Packet optical rerouting successful",
+                                onfail="Packet optical rerouting failed" )
+
+    def CASE4( self, main ):
+        import re
+        import time
+        main.log.report( "This testcase is testing the assignment of \
+                         all the switches to all the controllers and \
+                         discovering the hists in reactive mode" )
+        main.log.report( "__________________________________" )
+        main.case( "Pingall Test" )
+        main.step( "Assigning switches to controllers" )
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+        ONOS1Port = main.params[ 'CTRL' ][ 'port1' ]
+        for i in range( 1, 29 ):
+            if i == 1:
+                main.Mininet1.assignSwController(
+                    sw=str( i ),
+                    ip1=ONOS1Ip,
+                    port1=ONOS1Port )
+            elif i >= 2 and i < 5:
+                main.Mininet1.assignSwController(
+                    sw=str( i ),
+                    ip1=ONOS1Ip,
+                    port1=ONOS1Port )
+            elif i >= 5 and i < 8:
+                main.Mininet1.assignSwController(
+                    sw=str( i ),
+                    ip1=ONOS1Ip,
+                    port1=ONOS1Port )
+            elif i >= 8 and i < 18:
+                main.Mininet1.assignSwController(
+                    sw=str( i ),
+                    ip1=ONOS1Ip,
+                    port1=ONOS1Port )
+            elif i >= 18 and i < 28:
+                main.Mininet1.assignSwController(
+                    sw=str( i ),
+                    ip1=ONOS1Ip,
+                    port1=ONOS1Port )
+            else:
+                main.Mininet1.assignSwController(
+                    sw=str( i ),
+                    ip1=ONOS1Ip,
+                    port1=ONOS1Port )
+        SwitchMastership = main.TRUE
+        for i in range( 1, 29 ):
+            if i == 1:
+                response = main.Mininet1.getSwController( "s" + str( i ) )
+                print( "Response is " + str( response ) )
+                if re.search( "tcp:" + ONOS1Ip, response ):
+                    SwitchMastership = SwitchMastership and main.TRUE
+                else:
+                    SwitchMastership = main.FALSE
+            elif i >= 2 and i < 5:
+                response = main.Mininet1.getSwController( "s" + str( i ) )
+                print( "Response is " + str( response ) )
+                if re.search( "tcp:" + ONOS1Ip, response ):
+                    SwitchMastership = SwitchMastership and main.TRUE
+                else:
+                    SwitchMastership = main.FALSE
+            elif i >= 5 and i < 8:
+                response = main.Mininet1.getSwController( "s" + str( i ) )
+                print( "Response is " + str( response ) )
+                if re.search( "tcp:" + ONOS1Ip, response ):
+                    SwitchMastership = SwitchMastership and main.TRUE
+                else:
+                    SwitchMastership = main.FALSE
+            elif i >= 8 and i < 18:
+                response = main.Mininet1.getSwController( "s" + str( i ) )
+                print( "Response is " + str( response ) )
+                if re.search( "tcp:" + ONOS1Ip, response ):
+                    SwitchMastership = SwitchMastership and main.TRUE
+                else:
+                    SwitchMastership = main.FALSE
+            elif i >= 18 and i < 28:
+                response = main.Mininet1.getSwController( "s" + str( i ) )
+                print( "Response is " + str( response ) )
+                if re.search( "tcp:" + ONOS1Ip, response ):
+                    SwitchMastership = SwitchMastership and main.TRUE
+                else:
+                    SwitchMastership = main.FALSE
+            else:
+                response = main.Mininet1.getSwController( "s" + str( i ) )
+                print( "Response is" + str( response ) )
+                if re.search( "tcp:" + ONOS1Ip, response ):
+                    SwitchMastership = SwitchMastership and main.TRUE
+                else:
+                    SwitchMastership = main.FALSE
+
+        if SwitchMastership == main.TRUE:
+            main.log.report( "Controller assignmnet successful" )
+        else:
+            main.log.report( "Controller assignmnet failed" )
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=SwitchMastership,
+            onpass="MasterControllers assigned correctly" )
+        """
+        for i in range ( 1,29 ):
+            main.Mininet1.assignSwController( sw=str( i ),count=5,
+                    ip1=ONOS1Ip,port1=ONOS1Port,
+                    ip2=ONOS2Ip,port2=ONOS2Port,
+                    ip3=ONOS3Ip,port3=ONOS3Port,
+                    ip4=ONOS4Ip,port4=ONOS4Port,
+                    ip5=ONOS5Ip,port5=ONOS5Port )
+        """
+        # REACTIVE FWD test
+
+        main.step( "Get list of hosts from Mininet" )
+        hostList = main.Mininet1.getHosts()
+        main.log.info( hostList )
+
+        main.step( "Get host list in ONOS format" )
+        hostOnosList = main.ONOS2.getHostsId( hostList )
+        main.log.info( hostOnosList )
+        # time.sleep( 5 )
+
+        main.step( "Pingall" )
+        pingResult = main.FALSE
+        while pingResult == main.FALSE:
+            time1 = time.time()
+            pingResult = 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.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
+
+        case4Result = SwitchMastership and pingResult
+        if pingResult == main.TRUE:
+            main.log.report( "Pingall Test in reactive mode to \
+                             discover the hosts successful" )
+        else:
+            main.log.report( "Pingall Test in reactive mode to \
+                              discover the hosts failed" )
+
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case4Result,
+            onpass="Controller assignment and Pingall Test successful",
+            onfail="Controller assignment and Pingall Test NOT successful" )
+
+    def CASE10( self ):
+        main.log.report(
+            "This testcase uninstalls the reactive forwarding app" )
+        main.log.report( "__________________________________" )
+        main.case( "Uninstalling reactive forwarding app" )
+        # Unistall onos-app-fwd app to disable reactive forwarding
+        appUninstallResult = main.ONOS2.featureUninstall( "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 )
+
+        flows = main.ONOS2.flows()
+        main.log.info( flows )
+
+        case10Result = appUninstallResult
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case10Result,
+            onpass="Reactive forwarding app uninstallation successful",
+            onfail="Reactive forwarding app uninstallation failed" )
+
+    def CASE6( self ):
+        main.log.report( "This testcase is testing the addition of \
+                         host intents and then does pingall" )
+        main.log.report( "__________________________________" )
+        main.case( "Obtaining host id's" )
+        main.step( "Get hosts" )
+        hosts = main.ONOS2.hosts()
+        main.log.info( hosts )
+
+        main.step( "Get all devices id" )
+        devicesIdList = main.ONOS2.getAllDevicesId()
+        main.log.info( devicesIdList )
+
+        # 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" )
+        hthIntentResult = main.ONOS2.addHostIntent(
+                            "00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1" )
+        hthIntentResult = main.ONOS2.addHostIntent(
+                            "00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1" )
+        hthIntentResult = main.ONOS2.addHostIntent(
+                            "00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1" )
+        hthIntentResult = main.ONOS2.addHostIntent(
+                            "00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1" )
+        hthIntentResult = main.ONOS2.addHostIntent(
+                            "00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1" )
+        hthIntentResult = main.ONOS2.addHostIntent(
+                            "00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1" )
+        hthIntentResult = main.ONOS2.addHostIntent(
+                            "00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1" )
+        hthIntentResult = main.ONOS2.addHostIntent(
+                            "00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1" )
+        hthIntentResult = main.ONOS2.addHostIntent(
+                            "00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1" )
+        hthIntentResult = main.ONOS2.addHostIntent(
+                            "00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1" )
+        print "______________________________________________________"
+        """
+        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
+            host1Id = main.ONOS2.getHost( host1 )[ 'id' ]
+            host2Id = main.ONOS2.getHost( host2 )[ 'id' ]
+            main.ONOS2.addHostIntent( host1Id, host2Id )
+
+        time.sleep( 10 )
+        hIntents = main.ONOS2.intents( jsonFormat=False )
+        main.log.info( "intents:" + hIntents )
+        main.ONOS2.flows()
+
+        count = 1
+        i = 8
+        PingResult = 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
+                PingResult = 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 between h" +
+                                 str( i ) +
+                                 " and h" +
+                                 str( i +
+                                      10 ) +
+                                 "have failed" )
+                i = 19
+                PingResult = main.FALSE
+            elif ping == main.TRUE:
+                main.log.info( "Ping test between h" +
+                               str( i ) +
+                               " and h" +
+                               str( i +
+                                    10 ) +
+                               "passed!" )
+                i += 1
+                PingResult = main.TRUE
+            else:
+                main.log.info( "Unknown error" )
+                PingResult = main.ERROR
+        if PingResult == main.FALSE:
+            main.log.report(
+                "Ping all test after Host intent addition failed. Cleaning up" )
+            # main.cleanup()
+            # main.exit()
+        if PingResult == main.TRUE:
+            main.log.report(
+                "Ping all test after Host intent addition successful" )
+
+        case6Result = PingResult
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case6Result,
+            onpass="Pingall Test after Host intents addition successful",
+            onfail="Pingall Test after Host intents addition failed" )
+
+    def CASE5( self, main ):
+        import json
+        # assumes that sts is already in you PYTHONPATH
+        from sts.topology.testonTopology import TestONTopology
+        # main.ONOS2.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
+        main.log.report( "This testcase is testing if all ONOS nodes \
+                         are in topology sync with mininet" )
+        main.log.report( "__________________________________" )
+        main.case( "Comparing Mininet topology with the topology of ONOS" )
+        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
+
+        TopologyCheck = main.TRUE
+        main.step( "Compare ONOS Topology to MN Topology" )
+        devicesJson = main.ONOS2.devices()
+        linksJson = main.ONOS2.links()
+        # portsJson = main.ONOS2.ports()
+
+        result1 = main.Mininet1.compareSwitches(
+            MNTopo,
+            json.loads( devicesJson ) )
+        result2 = main.Mininet1.compareLinks(
+            MNTopo,
+            json.loads( linksJson ) )
+        # result3 = main.Mininet1.comparePorts(
+        # MNTopo, json.loads( portsJson ) )
+
+        # result = result1 and result2 and result3
+        result = result1 and result2
+
+        print "***********************"
+        if result == main.TRUE:
+            main.log.report( "ONOS" + " Topology matches MN Topology" )
+        else:
+            main.log.report( "ONOS" + " Topology does not match MN Topology" )
+
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=result,
+            onpass="ONOS" +
+            " Topology matches MN Topology",
+            onfail="ONOS" +
+            " Topology does not match MN Topology" )
+
+        TopologyCheck = TopologyCheck and result
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=TopologyCheck,
+            onpass="Topology checks passed",
+            onfail="Topology checks failed" )
+
+    def CASE7( self, main ):
+        from sts.topology.testonTopology import TestONTopology
+
+        linkSleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
+
+        main.log.report( "This testscase is killing a link to ensure that \
+                         link discovery is consistent" )
+        main.log.report( "__________________________________" )
+        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" )
+        topologyOutput = main.ONOS2.topology()
+        topologyResult = main.ONOS1.getTopology( topologyOutput )
+        activeSwitches = topologyResult[ 'devices' ]
+        links = topologyResult[ '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( linkSleep )
+        topologyOutput = main.ONOS2.topology()
+        LinkDown = main.ONOS1.checkStatus(
+            topologyOutput, activeSwitches, str(
+                int( links ) - 2 ) )
+        if LinkDown == main.TRUE:
+            main.log.report( "Link Down discovered properly" )
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=LinkDown,
+            onpass="Link Down discovered properly",
+            onfail="Link down was not discovered in " +
+            str( linkSleep ) +
+            " seconds" )
+
+        # Check ping result here..add code for it
+
+        main.step( "Bring link between s3 and s28 back up" )
+        LinkUp = main.Mininet1.link( END1="s3", END2="s28", OPTION="up" )
+        time.sleep( linkSleep )
+        topologyOutput = main.ONOS2.topology()
+        LinkUp = main.ONOS1.checkStatus(
+            topologyOutput,
+            activeSwitches,
+            str( links ) )
+        if LinkUp == main.TRUE:
+            main.log.report( "Link up discovered properly" )
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=LinkUp,
+            onpass="Link up discovered properly",
+            onfail="Link up was not discovered in " +
+            str( linkSleep ) +
+            " seconds" )
+
+        # NOTE Check ping result here..add code for it
+
+        main.step( "Compare ONOS Topology to MN Topology" )
+        Topo = TestONTopology(
+            main.Mininet1,
+            ctrls )  # can also add Intent API info for intent operations
+        MNTopo = Topo
+        TopologyCheck = main.TRUE
+
+        devicesJson = main.ONOS2.devices()
+        linksJson = main.ONOS2.links()
+        portsJson = main.ONOS2.ports()
+
+        result1 = main.Mininet1.compareSwitches(
+            MNTopo,
+            json.loads( devicesJson ) )
+        result2 = main.Mininet1.compareLinks(
+            MNTopo,
+            json.loads( linksJson ) )
+        # result3 = main.Mininet1.comparePorts(
+        # MNTopo, json.loads( portsJson ) )
+
+        # result = result1 and result2 and result3
+        result = result1 and result2
+        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" )
+
+        TopologyCheck = TopologyCheck and result
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=TopologyCheck,
+            onpass="Topology checks passed",
+            onfail="Topology checks failed" )
+
+        result = LinkDown and LinkUp and TopologyCheck
+        utilities.assert_equals( expect=main.TRUE, actual=result,
+                                onpass="Link failure is discovered correctly",
+                                onfail="Link Discovery failed" )
+
+    def CASE8( self ):
+        """
+        Host intents removal
+        """
+        main.log.report( "This testcase removes any previously added intents \
+                         before adding the same intents or point intents" )
+        main.log.report( "__________________________________" )
+        main.log.info( "Host intents removal" )
+        main.case( "Removing host intents" )
+        main.step( "Obtain the intent id's" )
+        intentResult = main.ONOS2.intents( jsonFormat=False )
+        main.log.info( "intent_result = " + intentResult )
+
+        intentLinewise = intentResult.split( "\n" )
+        intentList = []
+        for line in intentLinewise:
+            if line.startswith( "id=" ):
+                intentList.append( line )
+
+        intentids = []
+        for line in intentList:
+            intentids.append( line.split( "," )[ 0 ].split( "=" )[ 1 ] )
+        for id in intentids:
+            print "id = ", id
+
+        main.step(
+            "Iterate through the intentids list and remove each intent" )
+        for id in intentids:
+            main.ONOS2.removeIntent( intentId=id )
+
+        intentResult = main.ONOS2.intents( jsonFormat=False )
+        main.log.info( "intent_result = " + intentResult )
+
+        case8Result = main.TRUE
+        if case8Result == main.TRUE:
+            main.log.report( "Intent removal successful" )
+        else:
+            main.log.report( "Intent removal failed" )
+
+        PingResult = main.TRUE
+        if case8Result == main.TRUE:
+            i = 8
+            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.TRUE:
+                    i = 19
+                    PingResult = PingResult and main.TRUE
+                elif ping == main.FALSE:
+                    i += 1
+                    PingResult = PingResult and main.FALSE
+                else:
+                    main.log.info( "Unknown error" )
+                    PingResult = main.ERROR
+
+            # Note: If the ping result failed, that means the intents have been
+            # withdrawn correctly.
+        if PingResult == main.TRUE:
+            main.log.report( "Host intents have not been withdrawn correctly" )
+            # main.cleanup()
+            # main.exit()
+        if PingResult == main.FALSE:
+            main.log.report( "Host intents have been withdrawn correctly" )
+
+        case8Result = case8Result and PingResult
+
+        if case8Result == main.FALSE:
+            main.log.report( "Intent removal successful" )
+        else:
+            main.log.report( "Intent removal failed" )
+
+        utilities.assert_equals( expect=main.FALSE, actual=case8Result,
+                                onpass="Intent removal test failed",
+                                onfail="Intent removal test passed" )
+
+    def CASE9( self ):
+        main.log.report(
+            "This testcase adds point intents and then does pingall" )
+        main.log.report( "__________________________________" )
+        main.log.info( "Adding point intents" )
+        main.case(
+            "Adding bidirectional point for mn hosts \
+                  ( h8-h18, h9-h19, h10-h20, h11-h21, h12-h22,\
+                   h13-h23, h14-h24, h15-h25, h16-h26, h17-h27 )" )
+        main.step(
+            "Add point intents for mininet hosts h8 and h18 or \
+                  ONOS hosts h8 and h12" )
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000003008/1",
+            "of:0000000000006018/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000006018/1",
+            "of:0000000000003008/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        main.step(
+            "Add point intents for mininet hosts h9 and h19 or \
+                  ONOS hosts h9 and h13" )
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000003009/1",
+            "of:0000000000006019/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000006019/1",
+            "of:0000000000003009/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        main.step(
+            "Add point intents for mininet hosts h10 and h20 or \
+                  ONOS hosts hA and h14" )
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000003010/1",
+            "of:0000000000006020/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000006020/1",
+            "of:0000000000003010/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        main.step(
+            "Add point intents for mininet hosts h11 and h21 or \
+                  ONOS hosts hB and h15" )
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000003011/1",
+            "of:0000000000006021/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000006021/1",
+            "of:0000000000003011/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        main.step(
+            "Add point intents for mininet hosts h12 and h22 \
+                  ONOS hosts hC and h16" )
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000003012/1",
+            "of:0000000000006022/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000006022/1",
+            "of:0000000000003012/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        main.step(
+            "Add point intents for mininet hosts h13 and h23 or \
+                  ONOS hosts hD and h17" )
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000003013/1",
+            "of:0000000000006023/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000006023/1",
+            "of:0000000000003013/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        main.step(
+            "Add point intents for mininet hosts h14 and h24 or \
+                  ONOS hosts hE and h18" )
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000003014/1",
+            "of:0000000000006024/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000006024/1",
+            "of:0000000000003014/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        main.step(
+            "Add point intents for mininet hosts h15 and h25 or \
+                  ONOS hosts hF and h19" )
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000003015/1",
+            "of:0000000000006025/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000006025/1",
+            "of:0000000000003015/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        main.step(
+            "Add intents for mininet hosts h16 and h26 or \
+                  ONOS hosts h10 and h1A" )
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000003016/1",
+            "of:0000000000006026/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000006026/1",
+            "of:0000000000003016/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            # main.log.info( getIntentResult )
+
+        main.step(
+            "Add point intents for mininet hosts h17 and h27 or \
+                  ONOS hosts h11 and h1B" )
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000003017/1",
+            "of:0000000000006027/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            main.log.info( getIntentResult )
+
+        ptpIntentResult = main.ONOS2.addPointIntent(
+            "of:0000000000006027/1",
+            "of:0000000000003017/1" )
+        if ptpIntentResult == main.TRUE:
+            getIntentResult = main.ONOS2.intents()
+            main.log.info( "Point to point intent install successful" )
+            main.log.info( getIntentResult )
+
+        print(
+            "___________________________________________________________" )
+
+        flowHandle = main.ONOS2.flows()
+        # print "flowHandle = ", flowHandle
+        main.log.info( "flows :" + flowHandle )
+
+        count = 1
+        i = 8
+        PingResult = main.TRUE
+        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
+                PingResult = 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 between h" +
+                                 str( i ) +
+                                 " and h" +
+                                 str( i +
+                                      10 ) +
+                                 "have failed" )
+                i = 19
+                PingResult = main.FALSE
+            elif ping == main.TRUE:
+                main.log.info( "Ping test between h" +
+                               str( i ) +
+                               " and h" +
+                               str( i +
+                                    10 ) +
+                               "passed!" )
+                i += 1
+                PingResult = main.TRUE
+            else:
+                main.log.info( "Unknown error" )
+                PingResult = main.ERROR
+
+        if PingResult == main.FALSE:
+            main.log.report(
+                "Point intents have not ben installed correctly. Cleaning up" )
+            # main.cleanup()
+            # main.exit()
+        if PingResult == main.TRUE:
+            main.log.report( "Point Intents have been installed correctly" )
+
+        case9Result = PingResult
+        utilities.assert_equals(
+            expect=main.TRUE,
+            actual=case9Result,
+            onpass="Point intents addition and Pingall Test successful",
+            onfail="Point intents addition and Pingall Test NOT successful" )
diff --git a/TestON/tests/ProdFunc13/ProdFunc13.py b/TestON/tests/ProdFunc13/ProdFunc13.py
index f6f60ee..b1246c2 100644
--- a/TestON/tests/ProdFunc13/ProdFunc13.py
+++ b/TestON/tests/ProdFunc13/ProdFunc13.py
@@ -43,8 +43,8 @@
         main.step( "Removing raft logs before a clen installation of ONOS" )
         main.ONOSbench.onosRemoveRaftLogs()
 
-        main.step( "Git checkout and pull master and get version" )
-        main.ONOSbench.gitCheckout( "master" )
+        main.step( "Git checkout, pull and get version" )
+        #main.ONOSbench.gitCheckout( "master" )
         gitPullResult = main.ONOSbench.gitPull()
         main.log.info( "git_pull_result = " + gitPullResult )
         main.ONOSbench.getVersion( report=True )
diff --git a/TestON/tests/SdnIpTest/SdnIpTest.params b/TestON/tests/SdnIpTest/SdnIpTest.params
index bb5826d..7f7ef2d 100755
--- a/TestON/tests/SdnIpTest/SdnIpTest.params
+++ b/TestON/tests/SdnIpTest/SdnIpTest.params
@@ -1,6 +1,6 @@
 <PARAMS>
     
-    <testcases>1,2</testcases>
+    <testcases>4</testcases>
 
     #Environment variables
     <ENV>
diff --git a/TestON/tests/SdnIpTest/SdnIpTest.py b/TestON/tests/SdnIpTest/SdnIpTest.py
index 081b1ca..85ac21e 100644
--- a/TestON/tests/SdnIpTest/SdnIpTest.py
+++ b/TestON/tests/SdnIpTest/SdnIpTest.py
@@ -8,15 +8,27 @@
     def __init__( self ):
         self.default = ''
 
-    def CASE1( self, main ):
+# from cupshelpers.config import prefix
+
+# Testing the basic functionality of SDN-IP
+
+
+class SdnIpTest:
+
+    def __init__( self ):
+        self.default = ''
+
+    def CASE4( self, main ):
         """
         Test the SDN-IP functionality
-        allRoutes_expected: all expected routes for all BGP peers
-        routeIntents_expected: all expected MultiPointToSinglePointIntent intents
-        bgpIntents_expected: expected PointToPointIntent intents
-        allRoutes_actual: all routes from ONOS LCI
-        routeIntents_actual: actual MultiPointToSinglePointIntent intents from ONOS CLI
-        bgpIntents_actual: actual PointToPointIntent intents from ONOS CLI
+        allRoutesExpected: all expected routes for all BGP peers
+        routeIntentsExpected: all expected MultiPointToSinglePointIntent \
+        intents
+        bgpIntentsExpected: expected PointToPointIntent intents
+        allRoutesActual: all routes from ONOS LCI
+        routeIntentsActual: actual MultiPointToSinglePointIntent intents from \
+        ONOS CLI
+        bgpIntentsActual: actual PointToPointIntent intents from ONOS CLI
         """
         import time
         import json
@@ -24,124 +36,148 @@
         # from datetime import datetime
         from time import localtime, strftime
 
-        main.case(
-            "The test case is to help to setup the TestON environment and test new drivers" )
-        SDNIP_JSON_FILE_PATH = "../tests/SdnIpTest/sdnip.json"
+        main.case("The test case is to help to setup the TestON environment \
+            and test new drivers" )
+        # SDNIPJSONFILEPATH = "../tests/SdnIpTest/sdnip.json"
+        SDNIPJSONFILEPATH = \
+            "/home/admin/workspace/onos/tools/package/config/sdnip.json"
         # all expected routes for all BGP peers
-        allRoutes_expected = []
+        allRoutesExpected = []
         main.step( "Start to generate routes for all BGP peers" )
-        # bgpPeerHosts = []
-        # for i in range( 3, 5 ):
-        #    bgpPeerHosts.append( "host" + str( i ) )
-        # main.log.info( "BGP Peer Hosts are:" + bgpPeerHosts )
-
-        # for i in range( 3, 5 ):
-        #   QuaggaCliHost = "QuaggaCliHost" + str( i )
-        #  prefixes = main.QuaggaCliHost.generate_prefixes( 3, 10 )
-
-        # main.log.info( prefixes )
-        # allRoutes_expected.append( prefixes )
         main.log.info( "Generate prefixes for host3" )
-        prefixes_host3 = main.QuaggaCliHost3.generate_prefixes( 3, 10 )
-        main.log.info( prefixes_host3 )
+        prefixesHost3 = main.QuaggaCliHost3.generatePrefixes( 3, 10 )
+        main.log.info( prefixesHost3 )
         # generate route with next hop
-        for prefix in prefixes_host3:
-            allRoutes_expected.append( prefix + "/" + "192.168.20.1" )
-        routeIntents_expected_host3 = main.QuaggaCliHost3.generate_expected_onePeerRouteIntents(
-            prefixes_host3,
-            "192.168.20.1",
-            "00:00:00:00:02:02",
-            SDNIP_JSON_FILE_PATH )
+        for prefix in prefixesHost3:
+            allRoutesExpected.append( prefix + "/" + "192.168.20.1" )
+        routeIntentsExpectedHost3 = \
+            main.QuaggaCliHost3.generateExpectedOnePeerRouteIntents(
+            prefixesHost3, "192.168.20.1", "00:00:00:00:02:02",
+            SDNIPJSONFILEPATH )
 
         main.log.info( "Generate prefixes for host4" )
-        prefixes_host4 = main.QuaggaCliHost4.generate_prefixes( 4, 10 )
-        main.log.info( prefixes_host4 )
+        prefixesHost4 = main.QuaggaCliHost4.generatePrefixes( 4, 10 )
+        main.log.info( prefixesHost4 )
         # generate route with next hop
-        for prefix in prefixes_host4:
-            allRoutes_expected.append( prefix + "/" + "192.168.30.1" )
-        routeIntents_expected_host4 = main.QuaggaCliHost4.generate_expected_onePeerRouteIntents(
-            prefixes_host4,
-            "192.168.30.1",
-            "00:00:00:00:03:01",
-            SDNIP_JSON_FILE_PATH )
+        for prefix in prefixesHost4:
+            allRoutesExpected.append( prefix + "/" + "192.168.30.1" )
+        routeIntentsExpectedHost4 = \
+            main.QuaggaCliHost4.generateExpectedOnePeerRouteIntents(
+            prefixesHost4, "192.168.30.1", "00:00:00:00:03:01",
+            SDNIPJSONFILEPATH )
 
-        routeIntents_expected = routeIntents_expected_host3 + \
-            routeIntents_expected_host4
+        main.log.info( "Generate prefixes for host5" )
+        prefixesHost5 = main.QuaggaCliHost5.generatePrefixes( 5, 10 )
+        main.log.info( prefixesHost5 )
+        for prefix in prefixesHost5:
+            allRoutesExpected.append( prefix + "/" + "192.168.60.2" )
+        routeIntentsExpectedHost5 = \
+            main.QuaggaCliHost5.generateExpectedOnePeerRouteIntents(
+            prefixesHost5, "192.168.60.1", "00:00:00:00:06:02",
+            SDNIPJSONFILEPATH )
 
-        cell_name = main.params[ 'ENV' ][ 'cellName' ]
-        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+        routeIntentsExpected = routeIntentsExpectedHost3 + \
+            routeIntentsExpectedHost4 + routeIntentsExpectedHost5
+
+        cellName = main.params[ 'ENV' ][ 'cellName' ]
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
         main.step( "Set cell for ONOS-cli environment" )
-        main.ONOScli.set_cell( cell_name )
-        verify_result = main.ONOSbench.verify_cell()
-        main.log.report( "Removing raft logs" )
-        main.ONOSbench.onos_remove_raft_logs()
-        main.log.report( "Uninstalling ONOS" )
-        main.ONOSbench.onos_uninstall( ONOS1_ip )
-        main.step( "Creating ONOS package" )
-        package_result = main.ONOSbench.onos_package()
+        main.ONOScli.setCell( cellName )
+        verifyResult = main.ONOSbench.verifyCell()
 
-        main.step( "Starting ONOS service" )
-        # TODO: start ONOS from Mininet Script
-        # start_result = main.ONOSbench.onos_start( "127.0.0.1" )
+        main.log.report( "Removing raft logs" )
+        main.ONOSbench.onosRemoveRaftLogs()
+        main.log.report( "Uninstalling ONOS" )
+        main.ONOSbench.onosUninstall( ONOS1Ip )
+
         main.step( "Installing ONOS package" )
-        onos1_install_result = main.ONOSbench.onos_install(
-            options="-f",
-            node=ONOS1_ip )
+        onos1InstallResult = main.ONOSbench.onosInstall(
+            options="-f", node=ONOS1Ip )
 
         main.step( "Checking if ONOS is up yet" )
-        time.sleep( 60 )
-        onos1_isup = main.ONOSbench.isup( ONOS1_ip )
-        if not onos1_isup:
+        time.sleep( 150 )
+        onos1Isup = main.ONOSbench.isup( ONOS1Ip )
+        if not onos1Isup:
             main.log.report( "ONOS1 didn't start!" )
 
         main.step( "Start ONOS-cli" )
-        # TODO: change the hardcode in start_onos_cli method in ONOS CLI driver
 
-        main.ONOScli.start_onos_cli( ONOS1_ip )
+        main.ONOScli.startOnosCli( ONOS1Ip )
 
         main.step( "Get devices in the network" )
-        list_result = main.ONOScli.devices( json_format=False )
-        main.log.info( list_result )
+        listResult = main.ONOScli.devices( jsonFormat=False )
+        main.log.info( listResult )
         time.sleep( 10 )
         main.log.info( "Installing sdn-ip feature" )
-        main.ONOScli.feature_install( "onos-app-sdnip" )
+        main.ONOScli.featureInstall( "onos-app-sdnip" )
         time.sleep( 10 )
         main.step( "Login all BGP peers and add routes into peers" )
+
         main.log.info( "Login Quagga CLI on host3" )
         main.QuaggaCliHost3.loginQuagga( "1.168.30.2" )
         main.log.info( "Enter configuration model of Quagga CLI on host3" )
-        main.QuaggaCliHost3.enter_config( 64514 )
+        main.QuaggaCliHost3.enterConfig( 64514 )
         main.log.info( "Add routes to Quagga on host3" )
-        main.QuaggaCliHost3.add_routes( prefixes_host3, 1 )
+        main.QuaggaCliHost3.addRoutes( prefixesHost3, 1 )
 
         main.log.info( "Login Quagga CLI on host4" )
         main.QuaggaCliHost4.loginQuagga( "1.168.30.3" )
         main.log.info( "Enter configuration model of Quagga CLI on host4" )
-        main.QuaggaCliHost4.enter_config( 64516 )
+        main.QuaggaCliHost4.enterConfig( 64516 )
         main.log.info( "Add routes to Quagga on host4" )
-        main.QuaggaCliHost4.add_routes( prefixes_host4, 1 )
+        main.QuaggaCliHost4.addRoutes( prefixesHost4, 1 )
+
+        main.log.info( "Login Quagga CLI on host5" )
+        main.QuaggaCliHost5.loginQuagga( "1.168.30.5" )
+        main.log.info( "Enter configuration model of Quagga CLI on host5" )
+        main.QuaggaCliHost5.enterConfig( 64521 )
+        main.log.info( "Add routes to Quagga on host5" )
+        main.QuaggaCliHost5.addRoutes( prefixesHost5, 1 )
+
+        for i in range( 101, 201 ):
+            prefixesHostX = main.QuaggaCliHost.generatePrefixes( str( i ), 10 )
+            main.log.info( prefixesHostX )
+            for prefix in prefixesHostX:
+                allRoutesExpected.append(
+                    prefix + "/" + "192.168.40." + str( i - 100 ) )
+
+            routeIntentsExpectedHostX = \
+            main.QuaggaCliHost.generateExpectedOnePeerRouteIntents(
+                prefixesHostX, "192.168.40." + str( i - 100 ),
+                "00:00:%02d:00:00:90" % ( i - 101 ), SDNIPJSONFILEPATH )
+            routeIntentsExpected = routeIntentsExpected + \
+                routeIntentsExpectedHostX
+
+            main.log.info( "Login Quagga CLI on host" + str( i ) )
+            QuaggaCliHostX = getattr( main, ( 'QuaggaCliHost' + str( i ) ) )
+            QuaggaCliHostX.loginQuagga( "1.168.30." + str( i ) )
+            main.log.info(
+                "Enter configuration model of Quagga CLI on host" + str( i ) )
+            QuaggaCliHostX.enterConfig( 65000 + i - 100 )
+            main.log.info( "Add routes to Quagga on host" + str( i ) )
+            QuaggaCliHostX.addRoutes( prefixesHostX, 1 )
+
         time.sleep( 60 )
 
-        # get all routes inside SDN-IP
-        get_routes_result = main.ONOScli.routes( json_format=True )
+        # get routes inside SDN-IP
+        getRoutesResult = main.ONOScli.routes( jsonFormat=True )
 
         # parse routes from ONOS CLI
-        allRoutes_actual = main.QuaggaCliHost3.extract_actual_routes(
-            get_routes_result )
+        allRoutesActual = \
+            main.QuaggaCliHost3.extractActualRoutes( getRoutesResult )
 
-        allRoutes_str_expected = str( sorted( allRoutes_expected ) )
-        allRoutes_str_actual = str( allRoutes_actual ).replace( 'u', "" )
+        allRoutesStrExpected = str( sorted( allRoutesExpected ) )
+        allRoutesStrActual = str( allRoutesActual ).replace( 'u', "" )
         main.step( "Check routes installed" )
         main.log.info( "Routes expected:" )
-        main.log.info( allRoutes_str_expected )
+        main.log.info( allRoutesStrExpected )
         main.log.info( "Routes get from ONOS CLI:" )
-        main.log.info( allRoutes_str_actual )
-        utilities.assert_equals(
-            expect=allRoutes_str_expected,
-            actual=allRoutes_str_actual,
+        main.log.info( allRoutesStrActual )
+        utilities.assertEquals(
+            expect=allRoutesStrExpected, actual=allRoutesStrActual,
             onpass="***Routes in SDN-IP are correct!***",
             onfail="***Routes in SDN-IP are wrong!***" )
-        if( eq( allRoutes_str_expected, allRoutes_str_actual ) ):
+        if( eq( allRoutesStrExpected, allRoutesStrActual ) ):
             main.log.report(
                 "***Routes in SDN-IP after adding routes are correct!***" )
         else:
@@ -149,58 +185,57 @@
                 "***Routes in SDN-IP after adding routes are wrong!***" )
 
         time.sleep( 20 )
-        get_intents_result = main.ONOScli.intents( json_format=True )
+        getIntentsResult = main.ONOScli.intents( jsonFormat=True )
 
         main.step( "Check MultiPointToSinglePointIntent intents installed" )
-        # route_intents_expected are generated when generating routes
+        # routeIntentsExpected are generated when generating routes
         # get rpoute intents from ONOS CLI
-        routeIntents_actual = main.QuaggaCliHost3.extract_actual_routeIntents(
-            get_intents_result )
-        routeIntents_str_expected = str( sorted( routeIntents_expected ) )
-        routeIntents_str_actual = str( routeIntents_actual ).replace( 'u', "" )
+        routeIntentsActual = \
+            main.QuaggaCliHost3.extractActualRouteIntents(
+                getIntentsResult )
+        routeIntentsStrExpected = str( sorted( routeIntentsExpected ) )
+        routeIntentsStrActual = str( routeIntentsActual ).replace( 'u', "" )
         main.log.info( "MultiPointToSinglePoint intents expected:" )
-        main.log.info( routeIntents_str_expected )
+        main.log.info( routeIntentsStrExpected )
         main.log.info( "MultiPointToSinglePoint intents get from ONOS CLI:" )
-        main.log.info( routeIntents_str_actual )
-        utilities.assert_equals(
+        main.log.info( routeIntentsStrActual )
+        utilities.assertEquals(
             expect=True,
-            actual=eq(
-                routeIntents_str_expected,
-                routeIntents_str_actual ),
-            onpass="***MultiPointToSinglePoint Intents in SDN-IP are correct!***",
-            onfail="***MultiPointToSinglePoint Intents in SDN-IP are wrong!***" )
+            actual=eq( routeIntentsStrExpected, routeIntentsStrActual ),
+            onpass="***MultiPointToSinglePoint Intents in SDN-IP are \
+            correct!***",
+            onfail="***MultiPointToSinglePoint Intents in SDN-IP are \
+            wrong!***" )
 
-        if( eq( routeIntents_str_expected, routeIntents_str_actual ) ):
-            main.log.report(
-                "***MultiPointToSinglePoint Intents before deleting routes correct!***" )
+        if( eq( routeIntentsStrExpected, routeIntentsStrActual ) ):
+            main.log.report( "***MultiPointToSinglePoint Intents before \
+            deleting routes correct!***" )
         else:
-            main.log.report(
-                "***MultiPointToSinglePoint Intents before deleting routes wrong!***" )
+            main.log.report( "***MultiPointToSinglePoint Intents before \
+            deleting routes wrong!***" )
 
         main.step( "Check BGP PointToPointIntent intents installed" )
         # bgp intents expected
-        bgpIntents_expected = main.QuaggaCliHost3.generate_expected_bgpIntents(
-            SDNIP_JSON_FILE_PATH )
+        bgpIntentsExpected = \
+            main.QuaggaCliHost3.generateExpectedBgpIntents( SDNIPJSONFILEPATH )
         # get BGP intents from ONOS CLI
-        bgpIntents_actual = main.QuaggaCliHost3.extract_actual_bgpIntents(
-            get_intents_result )
+        bgpIntentsActual = \
+            main.QuaggaCliHost3.extractActualBgpIntents( getIntentsResult )
 
-        bgpIntents_str_expected = str( bgpIntents_expected ).replace( 'u', "" )
-        bgpIntents_str_actual = str( bgpIntents_actual )
+        bgpIntentsStrExpected = str( bgpIntentsExpected ).replace( 'u', "" )
+        bgpIntentsStrActual = str( bgpIntentsActual )
         main.log.info( "PointToPointIntent intents expected:" )
-        main.log.info( bgpIntents_str_expected )
+        main.log.info( bgpIntentsStrExpected )
         main.log.info( "PointToPointIntent intents get from ONOS CLI:" )
-        main.log.info( bgpIntents_str_actual )
+        main.log.info( bgpIntentsStrActual )
 
-        utilities.assert_equals(
+        utilities.assertEquals(
             expect=True,
-            actual=eq(
-                bgpIntents_str_expected,
-                bgpIntents_str_actual ),
+            actual=eq( bgpIntentsStrExpected, bgpIntentsStrActual ),
             onpass="***PointToPointIntent Intents in SDN-IP are correct!***",
             onfail="***PointToPointIntent Intents in SDN-IP are wrong!***" )
 
-        if ( eq( bgpIntents_str_expected, bgpIntents_str_actual ) ):
+        if ( eq( bgpIntentsStrExpected, bgpIntentsStrActual ) ):
             main.log.report(
                 "***PointToPointIntent Intents in SDN-IP are correct!***" )
         else:
@@ -210,71 +245,634 @@
         #============================= Ping Test ========================
         # wait until all MultiPointToSinglePoint
         time.sleep( 20 )
-        ping_test_script = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
-        ping_test_results_file = "~/SDNIP/SdnIpIntentDemo/log/CASE1-ping-results-before-delete-routes-" + \
-            strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
-        ping_test_results = main.QuaggaCliHost.ping_test(
-            "1.168.30.100",
-            ping_test_script,
-            ping_test_results_file )
-        main.log.info( ping_test_results )
-
-        # ping test
+        pingTestScript = "~/SDNIP/test-tools/CASE4-ping-as2host.sh"
+        pingTestResultsFile = \
+        "~/SDNIP/SdnIpIntentDemo/log/CASE4-ping-results-before-delete-routes-" \
+            + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
+        pingTestResults = main.QuaggaCliHost.pingTest(
+            "1.168.30.100", pingTestScript, pingTestResultsFile )
+        main.log.info( pingTestResults )
+        time.sleep( 20 )
 
         #============================= Deleting Routes ==================
         main.step( "Check deleting routes installed" )
-        main.QuaggaCliHost3.delete_routes( prefixes_host3, 1 )
-        main.QuaggaCliHost4.delete_routes( prefixes_host4, 1 )
+        main.QuaggaCliHost3.deleteRoutes( prefixesHost3, 1 )
+        main.QuaggaCliHost4.deleteRoutes( prefixesHost4, 1 )
+        main.QuaggaCliHost5.deleteRoutes( prefixesHost5, 1 )
 
-        # main.log.info( "main.ONOScli.get_routes_num() = " )
-        # main.log.info( main.ONOScli.get_routes_num() )
-        # utilities.assert_equals( expect="Total SDN-IP routes = 1", actual=
-        # main.ONOScli.get_routes_num(),
-        get_routes_result = main.ONOScli.routes( json_format=True )
-        allRoutes_actual = main.QuaggaCliHost3.extract_actual_routes(
-            get_routes_result )
+        for i in range( 101, 201 ):
+            prefixesHostX = main.QuaggaCliHost.generatePrefixes( str( i ), 10 )
+            main.log.info( prefixesHostX )
+            QuaggaCliHostX = getattr( main, ( 'QuaggaCliHost' + str( i ) ) )
+            QuaggaCliHostX.deleteRoutes( prefixesHostX, 1 )
+
+        getRoutesResult = main.ONOScli.routes( jsonFormat=True )
+        allRoutesActual = \
+            main.QuaggaCliHost3.extractActualRoutes( getRoutesResult )
         main.log.info( "allRoutes_actual = " )
-        main.log.info( allRoutes_actual )
+        main.log.info( allRoutesActual )
 
-        utilities.assert_equals(
-            expect="[]",
-            actual=str( allRoutes_actual ),
+        utilities.assertEquals(
+            expect="[]", actual=str( allRoutesActual ),
             onpass="***Route number in SDN-IP is 0, correct!***",
             onfail="***Routes number in SDN-IP is not 0, wrong!***" )
 
-        if( eq( allRoutes_str_expected, allRoutes_str_actual ) ):
+        if( eq( allRoutesStrExpected, allRoutesStrActual ) ):
             main.log.report( "***Routes in SDN-IP after deleting correct!***" )
         else:
             main.log.report( "***Routes in SDN-IP after deleting wrong!***" )
 
         main.step( "Check intents after deleting routes" )
-        get_intents_result = main.ONOScli.intents( json_format=True )
-        routeIntents_actual = main.QuaggaCliHost3.extract_actual_routeIntents(
-            get_intents_result )
+        getIntentsResult = main.ONOScli.intents( jsonFormat=True )
+        routeIntentsActual = \
+            main.QuaggaCliHost3.extractActualRouteIntents(
+                getIntentsResult )
         main.log.info( "main.ONOScli.intents()= " )
-        main.log.info( routeIntents_actual )
-        utilities.assert_equals(
-            expect="[]",
-            actual=str( routeIntents_actual ),
-            onpass="***MultiPointToSinglePoint Intents number in SDN-IP is 0, correct!***",
-            onfail="***MultiPointToSinglePoint Intents number in SDN-IP is 0, wrong!***" )
+        main.log.info( routeIntentsActual )
+        utilities.assertEquals(
+            expect="[]", actual=str( routeIntentsActual ),
+            onpass="***MultiPointToSinglePoint Intents number in SDN-IP is 0, \
+            correct!***",
+            onfail="***MultiPointToSinglePoint Intents number in SDN-IP is 0, \
+            wrong!***" )
 
-        if( eq( routeIntents_str_expected, routeIntents_str_actual ) ):
-            main.log.report(
-                "***MultiPointToSinglePoint Intents after deleting routes correct!***" )
+        if( eq( routeIntentsStrExpected, routeIntentsStrActual ) ):
+            main.log.report( "***MultiPointToSinglePoint Intents after \
+            deleting routes correct!***" )
         else:
-            main.log.report(
-                "***MultiPointToSinglePoint Intents after deleting routes wrong!***" )
+            main.log.report( "***MultiPointToSinglePoint Intents after \
+            deleting routes wrong!***" )
 
         time.sleep( 20 )
-        ping_test_script = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
-        ping_test_results_file = "~/SDNIP/SdnIpIntentDemo/log/CASE1-ping-results-after-delete-routes-" + \
-            strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
-        ping_test_results = main.QuaggaCliHost.ping_test(
-            "1.168.30.100",
-            ping_test_script,
-            ping_test_results_file )
-        main.log.info( ping_test_results )
+        pingTestScript = "~/SDNIP/test-tools/CASE4-ping-as2host.sh"
+        pingTestResultsFile = \
+        "~/SDNIP/SdnIpIntentDemo/log/CASE4-ping-results-after-delete-routes-" \
+            + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
+        pingTestResults = main.QuaggaCliHost.pingTest(
+            "1.168.30.100", pingTestScript, pingTestResultsFile )
+        main.log.info( pingTestResults )
+        time.sleep( 100 )
+
+        # main.step( "Test whether Mininet is started" )
+        # main.Mininet2.handle.sendline( "xterm host1" )
+        # main.Mininet2.handle.expect( "mininet>" )
+
+    def CASE3( self, main ):
+        """
+        Test the SDN-IP functionality
+        allRoutesExpected: all expected routes for all BGP peers
+        routeIntentsExpected: all expected MultiPointToSinglePointIntent intents
+        bgpIntentsExpected: expected PointToPointIntent intents
+        allRoutesActual: all routes from ONOS LCI
+        routeIntentsActual: actual MultiPointToSinglePointIntent intents from \
+        ONOS CLI
+        bgpIntentsActual: actual PointToPointIntent intents from ONOS CLI
+        """
+        import time
+        import json
+        from operator import eq
+        # from datetime import datetime
+        from time import localtime, strftime
+
+        main.case( "The test case is to help to setup the TestON \
+            environment and test new drivers" )
+        # SDNIPJSONFILEPATH = "../tests/SdnIpTest/sdnip.json"
+        SDNIPJSONFILEPATH = \
+            "/home/admin/workspace/onos/tools/package/config/sdnip.json"
+        # all expected routes for all BGP peers
+        allRoutesExpected = []
+        main.step( "Start to generate routes for all BGP peers" )
+        main.log.info( "Generate prefixes for host3" )
+        prefixesHost3 = main.QuaggaCliHost3.generatePrefixes( 3, 10 )
+        main.log.info( prefixesHost3 )
+        # generate route with next hop
+        for prefix in prefixesHost3:
+            allRoutesExpected.append( prefix + "/" + "192.168.20.1" )
+        routeIntentsExpectedHost3 = \
+            main.QuaggaCliHost3.generateExpectedOnePeerRouteIntents(
+            prefixesHost3, "192.168.20.1", "00:00:00:00:02:02",
+            SDNIPJSONFILEPATH )
+
+        main.log.info( "Generate prefixes for host4" )
+        prefixesHost4 = main.QuaggaCliHost4.generatePrefixes( 4, 10 )
+        main.log.info( prefixesHost4 )
+        # generate route with next hop
+        for prefix in prefixesHost4:
+            allRoutesExpected.append( prefix + "/" + "192.168.30.1" )
+        routeIntentsExpectedHost4 = \
+            main.QuaggaCliHost4.generateExpectedOnePeerRouteIntents(
+            prefixesHost4, "192.168.30.1", "00:00:00:00:03:01",
+            SDNIPJSONFILEPATH )
+
+        routeIntentsExpected = routeIntentsExpectedHost3 + \
+            routeIntentsExpectedHost4
+
+        cellName = main.params[ 'ENV' ][ 'cellName' ]
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+        main.step( "Set cell for ONOS-cli environment" )
+        main.ONOScli.setCell( cellName )
+        verifyResult = main.ONOSbench.verifyCell()
+
+        main.log.report( "Removing raft logs" )
+        main.ONOSbench.onosRemoveRaftLogs()
+        main.log.report( "Uninstalling ONOS" )
+        main.ONOSbench.onosUninstall( ONOS1Ip )
+
+        main.step( "Installing ONOS package" )
+        onos1InstallResult = main.ONOSbench.onosInstall(
+            options="-f", node=ONOS1Ip )
+
+        main.step( "Checking if ONOS is up yet" )
+        time.sleep( 60 )
+        onos1Isup = main.ONOSbench.isup( ONOS1Ip )
+        if not onos1Isup:
+            main.log.report( "ONOS1 didn't start!" )
+
+        main.step( "Start ONOS-cli" )
+
+        main.ONOScli.startOnosCli( ONOS1Ip )
+
+        main.step( "Get devices in the network" )
+        listResult = main.ONOScli.devices( jsonFormat=False )
+        main.log.info( listResult )
+        time.sleep( 10 )
+        main.log.info( "Installing sdn-ip feature" )
+        main.ONOScli.featureInstall( "onos-app-sdnip" )
+        time.sleep( 10 )
+        main.step( "Login all BGP peers and add routes into peers" )
+
+        main.log.info( "Login Quagga CLI on host3" )
+        main.QuaggaCliHost3.loginQuagga( "1.168.30.2" )
+        main.log.info( "Enter configuration model of Quagga CLI on host3" )
+        main.QuaggaCliHost3.enterConfig( 64514 )
+        main.log.info( "Add routes to Quagga on host3" )
+        main.QuaggaCliHost3.addRoutes( prefixesHost3, 1 )
+
+        main.log.info( "Login Quagga CLI on host4" )
+        main.QuaggaCliHost4.loginQuagga( "1.168.30.3" )
+        main.log.info( "Enter configuration model of Quagga CLI on host4" )
+        main.QuaggaCliHost4.enterConfig( 64516 )
+        main.log.info( "Add routes to Quagga on host4" )
+        main.QuaggaCliHost4.addRoutes( prefixesHost4, 1 )
+
+        for i in range( 101, 201 ):
+            prefixesHostX = \
+                main.QuaggaCliHost.generatePrefixes( str( i ), 10 )
+            main.log.info( prefixesHostX )
+            for prefix in prefixesHostX:
+                allRoutesExpected.append(
+                    prefix + "/" + "192.168.40." + str( i - 100 ) )
+
+            routeIntentsExpectedHostX = \
+                main.QuaggaCliHost.generateExpectedOnePeerRouteIntents(
+                prefixesHostX, "192.168.40." + str( i - 100 ),
+                "00:00:%02d:00:00:90" % ( i - 101 ), SDNIPJSONFILEPATH )
+            routeIntentsExpected = routeIntentsExpected + \
+                routeIntentsExpectedHostX
+
+            main.log.info( "Login Quagga CLI on host" + str( i ) )
+            QuaggaCliHostX = getattr( main, ( 'QuaggaCliHost' + str( i ) ) )
+            QuaggaCliHostX.loginQuagga( "1.168.30." + str( i ) )
+            main.log.info(
+                "Enter configuration model of Quagga CLI on host" + str( i ) )
+            QuaggaCliHostX.enterConfig( 65000 + i - 100 )
+            main.log.info( "Add routes to Quagga on host" + str( i ) )
+            QuaggaCliHostX.addRoutes( prefixesHostX, 1 )
+
+        time.sleep( 60 )
+
+        # get routes inside SDN-IP
+        getRoutesResult = main.ONOScli.routes( jsonFormat=True )
+
+        # parse routes from ONOS CLI
+        allRoutesActual = \
+            main.QuaggaCliHost3.extractActualRoutes( getRoutesResult )
+
+        allRoutesStrExpected = str( sorted( allRoutesExpected ) )
+        allRoutesStrActual = str( allRoutesActual ).replace( 'u', "" )
+        main.step( "Check routes installed" )
+        main.log.info( "Routes expected:" )
+        main.log.info( allRoutesStrExpected )
+        main.log.info( "Routes get from ONOS CLI:" )
+        main.log.info( allRoutesStrActual )
+        utilities.assertEquals(
+            expect=allRoutesStrExpected, actual=allRoutesStrActual,
+            onpass="***Routes in SDN-IP are correct!***",
+            onfail="***Routes in SDN-IP are wrong!***" )
+        if( eq( allRoutesStrExpected, allRoutesStrActual ) ):
+            main.log.report(
+                "***Routes in SDN-IP after adding routes are correct!***" )
+        else:
+            main.log.report(
+                "***Routes in SDN-IP after adding routes are wrong!***" )
+
+        time.sleep( 20 )
+        getIntentsResult = main.ONOScli.intents( jsonFormat=True )
+
+        main.step( "Check MultiPointToSinglePointIntent intents installed" )
+        # routeIntentsExpected are generated when generating routes
+        # get rpoute intents from ONOS CLI
+        routeIntentsActual = \
+            main.QuaggaCliHost3.extractActualRouteIntents(
+                getIntentsResult )
+        routeIntentsStrExpected = str( sorted( routeIntentsExpected ) )
+        routeIntentsStrActual = str( routeIntentsActual ).replace( 'u', "" )
+        main.log.info( "MultiPointToSinglePoint intents expected:" )
+        main.log.info( routeIntentsStrExpected )
+        main.log.info( "MultiPointToSinglePoint intents get from ONOS CLI:" )
+        main.log.info( routeIntentsStrActual )
+        utilities.assertEquals(
+            expect=True,
+            actual=eq( routeIntentsStrExpected, routeIntentsStrActual ),
+            onpass="***MultiPointToSinglePoint Intents in SDN-IP are \
+            correct!***",
+            onfail="***MultiPointToSinglePoint Intents in SDN-IP are \
+            wrong!***" )
+
+        if( eq( routeIntentsStrExpected, routeIntentsStrActual ) ):
+            main.log.report(
+                "***MultiPointToSinglePoint Intents before deleting routes \
+                correct!***" )
+        else:
+            main.log.report(
+                "***MultiPointToSinglePoint Intents before deleting routes \
+                wrong!***" )
+
+        main.step( "Check BGP PointToPointIntent intents installed" )
+        # bgp intents expected
+        bgpIntentsExpected = main.QuaggaCliHost3.generateExpectedBgpIntents(
+            SDNIPJSONFILEPATH )
+        # get BGP intents from ONOS CLI
+        bgpIntentsActual = main.QuaggaCliHost3.extractActualBgpIntents(
+            getIntentsResult )
+
+        bgpIntentsStrExpected = str( bgpIntentsExpected ).replace( 'u', "" )
+        bgpIntentsStrActual = str( bgpIntentsActual )
+        main.log.info( "PointToPointIntent intents expected:" )
+        main.log.info( bgpIntentsStrExpected )
+        main.log.info( "PointToPointIntent intents get from ONOS CLI:" )
+        main.log.info( bgpIntentsStrActual )
+
+        utilities.assertEquals(
+            expect=True,
+            actual=eq( bgpIntentsStrExpected, bgpIntentsStrActual ),
+            onpass="***PointToPointIntent Intents in SDN-IP are correct!***",
+            onfail="***PointToPointIntent Intents in SDN-IP are wrong!***" )
+
+        if ( eq( bgpIntentsStrExpected, bgpIntentsStrActual ) ):
+            main.log.report(
+                "***PointToPointIntent Intents in SDN-IP are correct!***" )
+        else:
+            main.log.report(
+                "***PointToPointIntent Intents in SDN-IP are wrong!***" )
+
+        #============================= Ping Test ========================
+        # wait until all MultiPointToSinglePoint
+        time.sleep( 20 )
+        pingTestScript = "~/SDNIP/test-tools/CASE3-ping-as2host.sh"
+        pingTestResultsFile = \
+        "~/SDNIP/SdnIpIntentDemo/log/CASE3-ping-results-before-delete-routes-" \
+            + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
+        pingTestResults = main.QuaggaCliHost.pingTest(
+            "1.168.30.100", pingTestScript, pingTestResultsFile )
+        main.log.info( pingTestResults )
+        time.sleep( 20 )
+
+        #============================= Deleting Routes ==================
+        main.step( "Check deleting routes installed" )
+        main.QuaggaCliHost3.deleteRoutes( prefixesHost3, 1 )
+        main.QuaggaCliHost4.deleteRoutes( prefixesHost4, 1 )
+        for i in range( 101, 201 ):
+            prefixesHostX = \
+                main.QuaggaCliHost.generatePrefixes( str( i ), 10 )
+            main.log.info( prefixesHostX )
+            QuaggaCliHostX = getattr( main, ( 'QuaggaCliHost' + str( i ) ) )
+            QuaggaCliHostX.deleteRoutes( prefixesHostX, 1 )
+
+        getRoutesResult = main.ONOScli.routes( jsonFormat=True )
+        allRoutesActual = main.QuaggaCliHost3.extractActualRoutes(
+            getRoutesResult )
+        main.log.info( "allRoutes_actual = " )
+        main.log.info( allRoutesActual )
+
+        utilities.assertEquals(
+            expect="[]", actual=str( allRoutesActual ),
+            onpass="***Route number in SDN-IP is 0, correct!***",
+            onfail="***Routes number in SDN-IP is not 0, wrong!***" )
+
+        if( eq( allRoutesStrExpected, allRoutesStrActual ) ):
+            main.log.report(
+                "***Routes in SDN-IP after deleting correct!***" )
+        else:
+            main.log.report(
+                "***Routes in SDN-IP after deleting wrong!***" )
+
+        main.step( "Check intents after deleting routes" )
+        getIntentsResult = main.ONOScli.intents( jsonFormat=True )
+        routeIntentsActual = \
+            main.QuaggaCliHost3.extractActualRouteIntents(
+                getIntentsResult )
+        main.log.info( "main.ONOScli.intents()= " )
+        main.log.info( routeIntentsActual )
+        utilities.assertEquals(
+            expect="[]", actual=str( routeIntentsActual ),
+            onpass="***MultiPointToSinglePoint Intents number in SDN-IP is \
+            0, correct!***",
+            onfail="***MultiPointToSinglePoint Intents number in SDN-IP is \
+            0, wrong!***" )
+
+        if( eq( routeIntentsStrExpected, routeIntentsStrActual ) ):
+            main.log.report(
+                "***MultiPointToSinglePoint Intents after deleting routes \
+                correct!***" )
+        else:
+            main.log.report(
+                "***MultiPointToSinglePoint Intents after deleting routes \
+                wrong!***" )
+
+        time.sleep( 20 )
+        pingTestScript = "~/SDNIP/test-tools/CASE3-ping-as2host.sh"
+        pingTestResultsFile = \
+        "~/SDNIP/SdnIpIntentDemo/log/CASE3-ping-results-after-delete-routes-" \
+            + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
+        pingTestResults = main.QuaggaCliHost.pingTest(
+            "1.168.30.100", pingTestScript, pingTestResultsFile )
+        main.log.info( pingTestResults )
+        time.sleep( 100 )
+
+        # main.step( "Test whether Mininet is started" )
+        # main.Mininet2.handle.sendline( "xterm host1" )
+        # main.Mininet2.handle.expect( "mininet>" )
+
+    def CASE1( self, main ):
+        """
+        Test the SDN-IP functionality
+        allRoutesExpected: all expected routes for all BGP peers
+        routeIntentsExpected: all expected MultiPointToSinglePointIntent \
+        intents
+        bgpIntentsExpected: expected PointToPointIntent intents
+        allRoutesActual: all routes from ONOS LCI
+        routeIntentsActual: actual MultiPointToSinglePointIntent intents \
+        from ONOS CLI
+        bgpIntentsActual: actual PointToPointIntent intents from ONOS CLI
+        """
+        import time
+        import json
+        from operator import eq
+        # from datetime import datetime
+        from time import localtime, strftime
+
+        main.case("The test case is to help to setup the TestON environment \
+            and test new drivers" )
+        SDNIPJSONFILEPATH = "../tests/SdnIpTest/sdnip.json"
+        # all expected routes for all BGP peers
+        allRoutesExpected = []
+        main.step( "Start to generate routes for all BGP peers" )
+        # bgpPeerHosts = []
+        # for i in range( 3, 5 ):
+        #    bgpPeerHosts.append( "host" + str( i ) )
+        # main.log.info( "BGP Peer Hosts are:" + bgpPeerHosts )
+
+        # for i in range( 3, 5 ):
+         #   QuaggaCliHost = "QuaggaCliHost" + str( i )
+          #  prefixes = main.QuaggaCliHost.generatePrefixes( 3, 10 )
+
+           # main.log.info( prefixes )
+            # allRoutesExpected.append( prefixes )
+        main.log.info( "Generate prefixes for host3" )
+        prefixesHost3 = main.QuaggaCliHost3.generatePrefixes( 3, 10 )
+        main.log.info( prefixesHost3 )
+        # generate route with next hop
+        for prefix in prefixesHost3:
+            allRoutesExpected.append( prefix + "/" + "192.168.20.1" )
+        routeIntentsExpectedHost3 = \
+            main.QuaggaCliHost3.generateExpectedOnePeerRouteIntents(
+            prefixesHost3, "192.168.20.1", "00:00:00:00:02:02",
+            SDNIPJSONFILEPATH )
+
+        main.log.info( "Generate prefixes for host4" )
+        prefixesHost4 = main.QuaggaCliHost4.generatePrefixes( 4, 10 )
+        main.log.info( prefixesHost4 )
+        # generate route with next hop
+        for prefix in prefixesHost4:
+            allRoutesExpected.append( prefix + "/" + "192.168.30.1" )
+        routeIntentsExpectedHost4 = \
+            main.QuaggaCliHost4.generateExpectedOnePeerRouteIntents(
+            prefixesHost4, "192.168.30.1", "00:00:00:00:03:01",
+            SDNIPJSONFILEPATH )
+
+        routeIntentsExpected = routeIntentsExpectedHost3 + \
+            routeIntentsExpectedHost4
+
+        cellName = main.params[ 'ENV' ][ 'cellName' ]
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+        main.step( "Set cell for ONOS-cli environment" )
+        main.ONOScli.setCell( cellName )
+        verifyResult = main.ONOSbench.verifyCell()
+        main.log.report( "Removing raft logs" )
+        main.ONOSbench.onosRemoveRaftLogs()
+        main.log.report( "Uninstalling ONOS" )
+        main.ONOSbench.onosUninstall( ONOS1Ip )
+        main.step( "Creating ONOS package" )
+        packageResult = main.ONOSbench.onosPackage()
+
+        main.step( "Starting ONOS service" )
+        # TODO: start ONOS from Mininet Script
+        # startResult = main.ONOSbench.onosStart( "127.0.0.1" )
+        main.step( "Installing ONOS package" )
+        onos1InstallResult = main.ONOSbench.onosInstall(
+            options="-f", node=ONOS1Ip )
+
+        main.step( "Checking if ONOS is up yet" )
+        time.sleep( 60 )
+        onos1Isup = main.ONOSbench.isup( ONOS1Ip )
+        if not onos1Isup:
+            main.log.report( "ONOS1 didn't start!" )
+
+        main.step( "Start ONOS-cli" )
+        # TODO: change the hardcode in startOnosCli method in ONOS CLI driver
+
+        main.ONOScli.startOnosCli( ONOS1Ip )
+
+        main.step( "Get devices in the network" )
+        listResult = main.ONOScli.devices( jsonFormat=False )
+        main.log.info( listResult )
+        time.sleep( 10 )
+        main.log.info( "Installing sdn-ip feature" )
+        main.ONOScli.featureInstall( "onos-app-sdnip" )
+        time.sleep( 10 )
+        main.step( "Login all BGP peers and add routes into peers" )
+        main.log.info( "Login Quagga CLI on host3" )
+        main.QuaggaCliHost3.loginQuagga( "1.168.30.2" )
+        main.log.info( "Enter configuration model of Quagga CLI on host3" )
+        main.QuaggaCliHost3.enterConfig( 64514 )
+        main.log.info( "Add routes to Quagga on host3" )
+        main.QuaggaCliHost3.addRoutes( prefixesHost3, 1 )
+
+        main.log.info( "Login Quagga CLI on host4" )
+        main.QuaggaCliHost4.loginQuagga( "1.168.30.3" )
+        main.log.info( "Enter configuration model of Quagga CLI on host4" )
+        main.QuaggaCliHost4.enterConfig( 64516 )
+        main.log.info( "Add routes to Quagga on host4" )
+        main.QuaggaCliHost4.addRoutes( prefixesHost4, 1 )
+        time.sleep( 60 )
+
+        # get all routes inside SDN-IP
+        getRoutesResult = main.ONOScli.routes( jsonFormat=True )
+
+        # parse routes from ONOS CLI
+        allRoutesActual = \
+            main.QuaggaCliHost3.extractActualRoutes( getRoutesResult )
+
+        allRoutesStrExpected = str( sorted( allRoutesExpected ) )
+        allRoutesStrActual = str( allRoutesActual ).replace( 'u', "" )
+        main.step( "Check routes installed" )
+        main.log.info( "Routes expected:" )
+        main.log.info( allRoutesStrExpected )
+        main.log.info( "Routes get from ONOS CLI:" )
+        main.log.info( allRoutesStrActual )
+        utilities.assertEquals(
+            expect=allRoutesStrExpected, actual=allRoutesStrActual,
+            onpass="***Routes in SDN-IP are correct!***",
+            onfail="***Routes in SDN-IP are wrong!***" )
+        if( eq( allRoutesStrExpected, allRoutesStrActual ) ):
+            main.log.report(
+                "***Routes in SDN-IP after adding routes are correct!***" )
+        else:
+            main.log.report(
+                "***Routes in SDN-IP after adding routes are wrong!***" )
+
+        time.sleep( 20 )
+        getIntentsResult = main.ONOScli.intents( jsonFormat=True )
+
+        main.step( "Check MultiPointToSinglePointIntent intents installed" )
+        # routeIntentsExpected are generated when generating routes
+        # get rpoute intents from ONOS CLI
+        routeIntentsActual = \
+            main.QuaggaCliHost3.extractActualRouteIntents(
+                getIntentsResult )
+        routeIntentsStrExpected = str( sorted( routeIntentsExpected ) )
+        routeIntentsStrActual = str( routeIntentsActual ).replace( 'u', "" )
+        main.log.info( "MultiPointToSinglePoint intents expected:" )
+        main.log.info( routeIntentsStrExpected )
+        main.log.info( "MultiPointToSinglePoint intents get from ONOS CLI:" )
+        main.log.info( routeIntentsStrActual )
+        utilities.assertEquals(
+            expect=True,
+            actual=eq( routeIntentsStrExpected, routeIntentsStrActual ),
+            onpass="***MultiPointToSinglePoint Intents in SDN-IP are \
+            correct!***",
+            onfail="***MultiPointToSinglePoint Intents in SDN-IP are \
+            wrong!***" )
+
+        if( eq( routeIntentsStrExpected, routeIntentsStrActual ) ):
+            main.log.report(
+                "***MultiPointToSinglePoint Intents before deleting routes \
+                correct!***" )
+        else:
+            main.log.report(
+                "***MultiPointToSinglePoint Intents before deleting routes \
+                wrong!***" )
+
+        main.step( "Check BGP PointToPointIntent intents installed" )
+        # bgp intents expected
+        bgpIntentsExpected = \
+            main.QuaggaCliHost3.generateExpectedBgpIntents( SDNIPJSONFILEPATH )
+        # get BGP intents from ONOS CLI
+        bgpIntentsActual = main.QuaggaCliHost3.extractActualBgpIntents(
+            getIntentsResult )
+
+        bgpIntentsStrExpected = str( bgpIntentsExpected ).replace( 'u', "" )
+        bgpIntentsStrActual = str( bgpIntentsActual )
+        main.log.info( "PointToPointIntent intents expected:" )
+        main.log.info( bgpIntentsStrExpected )
+        main.log.info( "PointToPointIntent intents get from ONOS CLI:" )
+        main.log.info( bgpIntentsStrActual )
+
+        utilities.assertEquals(
+            expect=True,
+            actual=eq( bgpIntentsStrExpected, bgpIntentsStrActual ),
+            onpass="***PointToPointIntent Intents in SDN-IP are correct!***",
+            onfail="***PointToPointIntent Intents in SDN-IP are wrong!***" )
+
+        if ( eq( bgpIntentsStrExpected, bgpIntentsStrActual ) ):
+            main.log.report(
+                "***PointToPointIntent Intents in SDN-IP are correct!***" )
+        else:
+            main.log.report(
+                "***PointToPointIntent Intents in SDN-IP are wrong!***" )
+
+        #============================= Ping Test ========================
+        # wait until all MultiPointToSinglePoint
+        time.sleep( 20 )
+        pingTestScript = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
+        pingTestResultsFile = \
+        "~/SDNIP/SdnIpIntentDemo/log/CASE1-ping-results-before-delete-routes-" \
+             + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
+        pingTestResults = main.QuaggaCliHost.pingTest(
+            "1.168.30.100", pingTestScript, pingTestResultsFile )
+        main.log.info( pingTestResults )
+
+        # ping test
+
+        #============================= Deleting Routes ==================
+        main.step( "Check deleting routes installed" )
+        main.QuaggaCliHost3.deleteRoutes( prefixesHost3, 1 )
+        main.QuaggaCliHost4.deleteRoutes( prefixesHost4, 1 )
+
+        # main.log.info( "main.ONOScli.get_routes_num() = " )
+        # main.log.info( main.ONOScli.getRoutesNum() )
+        # utilities.assertEquals( expect="Total SDN-IP routes = 1", actual=
+        # main.ONOScli.getRoutesNum(),
+        getRoutesResult = main.ONOScli.routes( jsonFormat=True )
+        allRoutesActual = \
+            main.QuaggaCliHost3.extractActualRoutes( getRoutesResult )
+        main.log.info( "allRoutes_actual = " )
+        main.log.info( allRoutesActual )
+
+        utilities.assertEquals(
+            expect="[]", actual=str( allRoutesActual ),
+            onpass="***Route number in SDN-IP is 0, correct!***",
+            onfail="***Routes number in SDN-IP is not 0, wrong!***" )
+
+        if( eq( allRoutesStrExpected, allRoutesStrActual ) ):
+            main.log.report(
+                "***Routes in SDN-IP after deleting correct!***" )
+        else:
+            main.log.report(
+                "***Routes in SDN-IP after deleting wrong!***" )
+
+        main.step( "Check intents after deleting routes" )
+        getIntentsResult = main.ONOScli.intents( jsonFormat=True )
+        routeIntentsActual = \
+            main.QuaggaCliHost3.extractActualRouteIntents(
+                getIntentsResult )
+        main.log.info( "main.ONOScli.intents()= " )
+        main.log.info( routeIntentsActual )
+        utilities.assertEquals(
+            expect="[]", actual=str( routeIntentsActual ),
+            onpass="***MultiPointToSinglePoint Intents number in SDN-IP is \
+            0, correct!***",
+            onfail="***MultiPointToSinglePoint Intents number in SDN-IP is \
+            0, wrong!***" )
+
+        if( eq( routeIntentsStrExpected, routeIntentsStrActual ) ):
+            main.log.report(
+                "***MultiPointToSinglePoint Intents after deleting routes \
+                correct!***" )
+        else:
+            main.log.report(
+                "***MultiPointToSinglePoint Intents after deleting routes \
+                wrong!***" )
+
+        time.sleep( 20 )
+        pingTestScript = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
+        pingTestResultsFile = \
+        "~/SDNIP/SdnIpIntentDemo/log/CASE1-ping-results-after-delete-routes-" \
+             + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
+        pingTestResults = main.QuaggaCliHost.pingTest(
+            "1.168.30.100", pingTestScript, pingTestResultsFile )
+        main.log.info( pingTestResults )
         time.sleep( 30 )
 
         # main.step( "Test whether Mininet is started" )
@@ -284,12 +882,14 @@
     def CASE2( self, main ):
         """
         Test the SDN-IP functionality
-        allRoutes_expected: all expected routes for all BGP peers
-        routeIntents_expected: all expected MultiPointToSinglePointIntent intents
-        bgpIntents_expected: expected PointToPointIntent intents
-        allRoutes_actual: all routes from ONOS LCI
-        routeIntents_actual: actual MultiPointToSinglePointIntent intents from ONOS CLI
-        bgpIntents_actual: actual PointToPointIntent intents from ONOS CLI
+        allRoutesExpected: all expected routes for all BGP peers
+        routeIntentsExpected: all expected MultiPointToSinglePointIntent \
+        intents
+        bgpIntentsExpected: expected PointToPointIntent intents
+        allRoutesActual: all routes from ONOS LCI
+        routeIntentsActual: actual MultiPointToSinglePointIntent intents \
+        from ONOS CLI
+        bgpIntentsActual: actual PointToPointIntent intents from ONOS CLI
         """
         import time
         import json
@@ -297,227 +897,225 @@
         from time import localtime, strftime
 
         main.case(
-            "The test case is to help to setup the TestON environment and test new drivers" )
-        SDNIP_JSON_FILE_PATH = "../tests/SdnIpTest/sdnip.json"
+            "The test case is to help to setup the TestON environment and \
+            test new drivers" )
+        SDNIPJSONFILEPATH = "../tests/SdnIpTest/sdnip.json"
         # all expected routes for all BGP peers
-        allRoutes_expected = []
+        allRoutesExpected = []
         main.step( "Start to generate routes for all BGP peers" )
 
         main.log.info( "Generate prefixes for host3" )
-        prefixes_host3 = main.QuaggaCliHost3.generate_prefixes( 3, 10 )
-        main.log.info( prefixes_host3 )
+        prefixesHost3 = main.QuaggaCliHost3.generatePrefixes( 3, 10 )
+        main.log.info( prefixesHost3 )
         # generate route with next hop
-        for prefix in prefixes_host3:
-            allRoutes_expected.append( prefix + "/" + "192.168.20.1" )
-        routeIntents_expected_host3 = main.QuaggaCliHost3.generate_expected_onePeerRouteIntents(
-            prefixes_host3,
-            "192.168.20.1",
-            "00:00:00:00:02:02",
-            SDNIP_JSON_FILE_PATH )
+        for prefix in prefixesHost3:
+            allRoutesExpected.append( prefix + "/" + "192.168.20.1" )
+        routeIntentsExpectedHost3 = \
+            main.QuaggaCliHost3.generateExpectedOnePeerRouteIntents(
+            prefixesHost3, "192.168.20.1", "00:00:00:00:02:02",
+            SDNIPJSONFILEPATH )
 
         main.log.info( "Generate prefixes for host4" )
-        prefixes_host4 = main.QuaggaCliHost4.generate_prefixes( 4, 10 )
-        main.log.info( prefixes_host4 )
+        prefixesHost4 = main.QuaggaCliHost4.generatePrefixes( 4, 10 )
+        main.log.info( prefixesHost4 )
         # generate route with next hop
-        for prefix in prefixes_host4:
-            allRoutes_expected.append( prefix + "/" + "192.168.30.1" )
-        routeIntents_expected_host4 = main.QuaggaCliHost4.generate_expected_onePeerRouteIntents(
-            prefixes_host4,
-            "192.168.30.1",
-            "00:00:00:00:03:01",
-            SDNIP_JSON_FILE_PATH )
+        for prefix in prefixesHost4:
+            allRoutesExpected.append( prefix + "/" + "192.168.30.1" )
+        routeIntentsExpectedHost4 = \
+            main.QuaggaCliHost4.generateExpectedOnePeerRouteIntents(
+            prefixesHost4, "192.168.30.1", "00:00:00:00:03:01",
+            SDNIPJSONFILEPATH )
 
-        routeIntents_expected = routeIntents_expected_host3 + \
-            routeIntents_expected_host4
+        routeIntentsExpected = routeIntentsExpectedHost3 + \
+            routeIntentsExpectedHost4
 
         main.log.report( "Removing raft logs" )
-        main.ONOSbench.onos_remove_raft_logs()
+        main.ONOSbench.onosRemoveRaftLogs()
         main.log.report( "Uninstalling ONOS" )
-        main.ONOSbench.onos_uninstall( ONOS1_ip )
+        main.ONOSbench.onosUninstall( ONOS1Ip )
 
-        cell_name = main.params[ 'ENV' ][ 'cellName' ]
-        ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+        cellName = main.params[ 'ENV' ][ 'cellName' ]
+        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
         main.step( "Set cell for ONOS-cli environment" )
-        main.ONOScli.set_cell( cell_name )
-        verify_result = main.ONOSbench.verify_cell()
-        #main.log.report( "Removing raft logs" )
-        # main.ONOSbench.onos_remove_raft_logs()
-        #main.log.report( "Uninstalling ONOS" )
-        # main.ONOSbench.onos_uninstall( ONOS1_ip )
+        main.ONOScli.setCell( cellName )
+        verifyResult = main.ONOSbench.verifyCell()
+        # main.log.report( "Removing raft logs" )
+        # main.ONOSbench.onosRemoveRaftLogs()
+        # main.log.report( "Uninstalling ONOS" )
+        # main.ONOSbench.onosUninstall( ONOS1Ip )
         main.step( "Creating ONOS package" )
-        package_result = main.ONOSbench.onos_package()
+        # packageResult = main.ONOSbench.onosPackage()
 
         main.step( "Installing ONOS package" )
-        onos1_install_result = main.ONOSbench.onos_install(
-            options="-f",
-            node=ONOS1_ip )
+        # onos1InstallResult = main.ONOSbench.onosInstall( options="-f",
+        # node=ONOS1Ip )
 
         main.step( "Checking if ONOS is up yet" )
-        time.sleep( 60 )
-        onos1_isup = main.ONOSbench.isup( ONOS1_ip )
-        if not onos1_isup:
+        # time.sleep( 60 )
+        onos1Isup = main.ONOSbench.isup( ONOS1Ip )
+        if not onos1Isup:
             main.log.report( "ONOS1 didn't start!" )
 
         main.step( "Start ONOS-cli" )
-        main.ONOScli.start_onos_cli( ONOS1_ip )
+        main.ONOScli.startOnosCli( ONOS1Ip )
 
         main.step( "Get devices in the network" )
-        list_result = main.ONOScli.devices( json_format=False )
-        main.log.info( list_result )
+        listResult = main.ONOScli.devices( jsonFormat=False )
+        main.log.info( listResult )
         time.sleep( 10 )
         main.log.info( "Installing sdn-ip feature" )
-        main.ONOScli.feature_install( "onos-app-sdnip" )
+        main.ONOScli.featureInstall( "onos-app-sdnip" )
         time.sleep( 10 )
 
         main.step( "Check BGP PointToPointIntent intents installed" )
         # bgp intents expected
-        bgpIntents_expected = main.QuaggaCliHost3.generate_expected_bgpIntents(
-            SDNIP_JSON_FILE_PATH )
+        bgpIntentsExpected = main.QuaggaCliHost3.generateExpectedBgpIntents(
+            SDNIPJSONFILEPATH )
         # get BGP intents from ONOS CLI
-        get_intents_result = main.ONOScli.intents( json_format=True )
-        bgpIntents_actual = main.QuaggaCliHost3.extract_actual_bgpIntents(
-            get_intents_result )
+        getIntentsResult = main.ONOScli.intents( jsonFormat=True )
+        bgpIntentsActual = main.QuaggaCliHost3.extractActualBgpIntents(
+            getIntentsResult )
 
-        bgpIntents_str_expected = str( bgpIntents_expected ).replace( 'u', "" )
-        bgpIntents_str_actual = str( bgpIntents_actual )
+        bgpIntentsStrExpected = str( bgpIntentsExpected ).replace( 'u', "" )
+        bgpIntentsStrActual = str( bgpIntentsActual )
         main.log.info( "PointToPointIntent intents expected:" )
-        main.log.info( bgpIntents_str_expected )
+        main.log.info( bgpIntentsStrExpected )
         main.log.info( "PointToPointIntent intents get from ONOS CLI:" )
-        main.log.info( bgpIntents_str_actual )
+        main.log.info( bgpIntentsStrActual )
 
-        utilities.assert_equals(
+        utilities.assertEquals(
             expect=True,
-            actual=eq(
-                bgpIntents_str_expected,
-                bgpIntents_str_actual ),
+            actual=eq( bgpIntentsStrExpected, bgpIntentsStrActual ),
             onpass="***PointToPointIntent Intents in SDN-IP are correct!***",
             onfail="***PointToPointIntent Intents in SDN-IP are wrong!***" )
 
-        if ( eq( bgpIntents_str_expected, bgpIntents_str_actual ) ):
+        if ( eq( bgpIntentsStrExpected, bgpIntentsStrActual ) ):
             main.log.report(
                 "***PointToPointIntent Intents in SDN-IP are correct!***" )
         else:
             main.log.report(
                 "***PointToPointIntent Intents in SDN-IP are wrong!***" )
 
-        allRoutes_str_expected = str( sorted( allRoutes_expected ) )
-        routeIntents_str_expected = str( sorted( routeIntents_expected ) )
-        ping_test_script = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
-        # round_num = 0;
+        allRoutesStrExpected = str( sorted( allRoutesExpected ) )
+        routeIntentsStrExpected = str( sorted( routeIntentsExpected ) )
+        pingTestScript = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
+        # roundNum = 0;
         # while( True ):
-        for round_num in range( 1, 6 ):
+        for roundNum in range( 1, 6 ):
             # round = round + 1;
-            main.log.report(
-                "The Round " +
-                str( round_num ) +
-                " test starts........................................" )
+            main.log.report( "The Round " + str( roundNum ) +
+                             " test starts................................" )
 
             main.step( "Login all BGP peers and add routes into peers" )
             main.log.info( "Login Quagga CLI on host3" )
             main.QuaggaCliHost3.loginQuagga( "1.168.30.2" )
-            main.log.info( "Enter configuration model of Quagga CLI on host3" )
-            main.QuaggaCliHost3.enter_config( 64514 )
+            main.log.info(
+                "Enter configuration model of Quagga CLI on host3" )
+            main.QuaggaCliHost3.enterConfig( 64514 )
             main.log.info( "Add routes to Quagga on host3" )
-            main.QuaggaCliHost3.add_routes( prefixes_host3, 1 )
+            main.QuaggaCliHost3.addRoutes( prefixesHost3, 1 )
 
             main.log.info( "Login Quagga CLI on host4" )
             main.QuaggaCliHost4.loginQuagga( "1.168.30.3" )
-            main.log.info( "Enter configuration model of Quagga CLI on host4" )
-            main.QuaggaCliHost4.enter_config( 64516 )
+            main.log.info(
+                "Enter configuration model of Quagga CLI on host4" )
+            main.QuaggaCliHost4.enterConfig( 64516 )
             main.log.info( "Add routes to Quagga on host4" )
-            main.QuaggaCliHost4.add_routes( prefixes_host4, 1 )
+            main.QuaggaCliHost4.addRoutes( prefixesHost4, 1 )
             time.sleep( 60 )
 
             # get all routes inside SDN-IP
-            get_routes_result = main.ONOScli.routes( json_format=True )
+            getRoutesResult = main.ONOScli.routes( jsonFormat=True )
 
             # parse routes from ONOS CLI
-            allRoutes_actual = main.QuaggaCliHost3.extract_actual_routes(
-                get_routes_result )
+            allRoutesActual = \
+                main.QuaggaCliHost3.extractActualRoutes( getRoutesResult )
 
-            # allRoutes_str_expected = str( sorted( allRoutes_expected ) )
-            allRoutes_str_actual = str( allRoutes_actual ).replace( 'u', "" )
+            # allRoutesStrExpected = str( sorted( allRoutesExpected ) )
+            allRoutesStrActual = str( allRoutesActual ).replace( 'u', "" )
             main.step( "Check routes installed" )
             main.log.info( "Routes expected:" )
-            main.log.info( allRoutes_str_expected )
+            main.log.info( allRoutesStrExpected )
             main.log.info( "Routes get from ONOS CLI:" )
-            main.log.info( allRoutes_str_actual )
-            utilities.assert_equals(
-                expect=allRoutes_str_expected,
-                actual=allRoutes_str_actual,
+            main.log.info( allRoutesStrActual )
+            utilities.assertEquals(
+                expect=allRoutesStrExpected, actual=allRoutesStrActual,
                 onpass="***Routes in SDN-IP are correct!***",
                 onfail="***Routes in SDN-IP are wrong!***" )
-            if( eq( allRoutes_str_expected, allRoutes_str_actual ) ):
+            if( eq( allRoutesStrExpected, allRoutesStrActual ) ):
                 main.log.report(
                     "***Routes in SDN-IP after adding correct!***" )
             else:
-                main.log.report( "***Routes in SDN-IP after adding wrong!***" )
+                main.log.report(
+                    "***Routes in SDN-IP after adding wrong!***" )
 
             time.sleep( 20 )
-            get_intents_result = main.ONOScli.intents( json_format=True )
+            getIntentsResult = main.ONOScli.intents( jsonFormat=True )
 
             main.step(
                 "Check MultiPointToSinglePointIntent intents installed" )
-            # route_intents_expected are generated when generating routes
+            # routeIntentsExpected are generated when generating routes
             # get route intents from ONOS CLI
-            routeIntents_actual = main.QuaggaCliHost3.extract_actual_routeIntents(
-                get_intents_result )
-            # routeIntents_str_expected = str( sorted( routeIntents_expected ) )
-            routeIntents_str_actual = str(
-                routeIntents_actual ).replace( 'u', "" )
+            routeIntentsActual = \
+                main.QuaggaCliHost3.extractActualRouteIntents(
+                    getIntentsResult )
+            # routeIntentsStrExpected = str( sorted( routeIntentsExpected ) )
+            routeIntentsStrActual = str(
+                routeIntentsActual ).replace( 'u', "" )
             main.log.info( "MultiPointToSinglePoint intents expected:" )
-            main.log.info( routeIntents_str_expected )
+            main.log.info( routeIntentsStrExpected )
             main.log.info(
                 "MultiPointToSinglePoint intents get from ONOS CLI:" )
-            main.log.info( routeIntents_str_actual )
-            utilities.assert_equals(
+            main.log.info( routeIntentsStrActual )
+            utilities.assertEquals(
                 expect=True,
-                actual=eq(
-                    routeIntents_str_expected,
-                    routeIntents_str_actual ),
-                onpass="***MultiPointToSinglePoint Intents in SDN-IP are correct!***",
-                onfail="***MultiPointToSinglePoint Intents in SDN-IP are wrong!***" )
+                actual=eq( routeIntentsStrExpected, routeIntentsStrActual ),
+                onpass="***MultiPointToSinglePoint Intents in SDN-IP are \
+                correct!***",
+                onfail="***MultiPointToSinglePoint Intents in SDN-IP are \
+                wrong!***" )
 
-            if( eq( routeIntents_str_expected, routeIntents_str_actual ) ):
+            if( eq( routeIntentsStrExpected, routeIntentsStrActual ) ):
                 main.log.report(
-                    "***MultiPointToSinglePoint Intents after adding routes correct!***" )
+                    "***MultiPointToSinglePoint Intents after adding routes \
+                    correct!***" )
             else:
                 main.log.report(
-                    "***MultiPointToSinglePoint Intents after adding routes wrong!***" )
+                    "***MultiPointToSinglePoint Intents after adding routes \
+                    wrong!***" )
 
             #============================= Ping Test ========================
             # wait until all MultiPointToSinglePoint
             time.sleep( 20 )
-            # ping_test_script = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
-            ping_test_results_file = "~/SDNIP/SdnIpIntentDemo/log/CASE2-Round" + \
-                str( round_num ) + "-ping-results-before-delete-routes-" + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
-            ping_test_results = main.QuaggaCliHost.ping_test(
-                "1.168.30.100",
-                ping_test_script,
-                ping_test_results_file )
-            main.log.info( ping_test_results )
+            # pingTestScript = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
+            pingTestResultsFile = \
+                "~/SDNIP/SdnIpIntentDemo/log/CASE2-Round" \
+                + str( roundNum ) + "-ping-results-before-delete-routes-" \
+                + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
+            pingTestResults = main.QuaggaCliHost.pingTest(
+                "1.168.30.100", pingTestScript, pingTestResultsFile )
+            main.log.info( pingTestResults )
             # ping test
 
             #============================= Deleting Routes ==================
             main.step( "Check deleting routes installed" )
             main.log.info( "Delete routes to Quagga on host3" )
-            main.QuaggaCliHost3.delete_routes( prefixes_host3, 1 )
+            main.QuaggaCliHost3.deleteRoutes( prefixesHost3, 1 )
             main.log.info( "Delete routes to Quagga on host4" )
-            main.QuaggaCliHost4.delete_routes( prefixes_host4, 1 )
+            main.QuaggaCliHost4.deleteRoutes( prefixesHost4, 1 )
 
-            get_routes_result = main.ONOScli.routes( json_format=True )
-            allRoutes_actual = main.QuaggaCliHost3.extract_actual_routes(
-                get_routes_result )
+            getRoutesResult = main.ONOScli.routes( jsonFormat=True )
+            allRoutesActual = \
+                main.QuaggaCliHost3.extractActualRoutes( getRoutesResult )
             main.log.info( "allRoutes_actual = " )
-            main.log.info( allRoutes_actual )
+            main.log.info( allRoutesActual )
 
-            utilities.assert_equals(
-                expect="[]",
-                actual=str( allRoutes_actual ),
+            utilities.assertEquals(
+                expect="[]", actual=str( allRoutesActual ),
                 onpass="***Route number in SDN-IP is 0, correct!***",
                 onfail="***Routes number in SDN-IP is not 0, wrong!***" )
 
-            if( eq( allRoutes_str_expected, allRoutes_str_actual ) ):
+            if( eq( allRoutesStrExpected, allRoutesStrActual ) ):
                 main.log.report(
                     "***Routes in SDN-IP after deleting correct!***" )
             else:
@@ -525,31 +1123,37 @@
                     "***Routes in SDN-IP after deleting wrong!***" )
 
             main.step( "Check intents after deleting routes" )
-            get_intents_result = main.ONOScli.intents( json_format=True )
-            routeIntents_actual = main.QuaggaCliHost3.extract_actual_routeIntents(
-                get_intents_result )
+            getIntentsResult = main.ONOScli.intents( jsonFormat=True )
+            routeIntentsActual = \
+                main.QuaggaCliHost3.extractActualRouteIntents(
+                    getIntentsResult )
             main.log.info( "main.ONOScli.intents()= " )
-            main.log.info( routeIntents_actual )
-            utilities.assert_equals(
-                expect="[]",
-                actual=str( routeIntents_actual ),
-                onpass="***MultiPointToSinglePoint Intents number in SDN-IP is 0, correct!***",
-                onfail="***MultiPointToSinglePoint Intents number in SDN-IP is 0, wrong!***" )
+            main.log.info( routeIntentsActual )
+            utilities.assertEquals(
+                expect="[]", actual=str( routeIntentsActual ),
+                onpass=
+                "***MultiPointToSinglePoint Intents number in SDN-IP \
+                is 0, correct!***",
+                onfail="***MultiPointToSinglePoint Intents number in SDN-IP \
+                is 0, wrong!***" )
 
-            if( eq( routeIntents_str_expected, routeIntents_str_actual ) ):
+            if( eq( routeIntentsStrExpected, routeIntentsStrActual ) ):
                 main.log.report(
-                    "***MultiPointToSinglePoint Intents after deleting routes correct!***" )
+                    "***MultiPointToSinglePoint Intents after deleting \
+                    routes correct!***" )
             else:
                 main.log.report(
-                    "***MultiPointToSinglePoint Intents after deleting routes wrong!***" )
+                    "***MultiPointToSinglePoint Intents after deleting \
+                    routes wrong!***" )
 
             time.sleep( 20 )
-            # ping_test_script = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
-            ping_test_results_file = "~/SDNIP/SdnIpIntentDemo/log/CASE2-Round" + \
-                str( round_num ) + "-ping-results-after-delete-routes-" + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
-            ping_test_results = main.QuaggaCliHost.ping_test(
-                "1.168.30.100",
-                ping_test_script,
-                ping_test_results_file )
-            main.log.info( ping_test_results )
+            # pingTestScript = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
+            pingTestResultsFile = \
+                "~/SDNIP/SdnIpIntentDemo/log/CASE2-Round" \
+                + str( roundNum ) + "-ping-results-after-delete-routes-" \
+                + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
+            pingTestResults = main.QuaggaCliHost.pingTest(
+                "1.168.30.100", pingTestScript, pingTestResultsFile )
+            main.log.info( pingTestResults )
             time.sleep( 30 )
+
diff --git a/TestON/tests/SdnIpTest/SdnIpTest.topo b/TestON/tests/SdnIpTest/SdnIpTest.topo
index 6df1975..fe9d1bb 100755
--- a/TestON/tests/SdnIpTest/SdnIpTest.topo
+++ b/TestON/tests/SdnIpTest/SdnIpTest.topo
@@ -33,7 +33,7 @@
             <user>admin</user>
             <password>onos_test</password>
             <type>QuaggaCliDriver</type>
-            <connect_order>5</connect_order>
+            <connect_order>4</connect_order>
             <COMPONENTS> </COMPONENTS>
         </QuaggaCliHost3>
         <QuaggaCliHost4>
@@ -44,14 +44,827 @@
             <connect_order>5</connect_order>
             <COMPONENTS> </COMPONENTS>
         </QuaggaCliHost4>
+        <QuaggaCliHost5>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>6</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost5>
+
         <QuaggaCliHost>
             <host>127.0.0.1</host>
             <user>admin</user>
             <password>onos_test</password>
             <type>QuaggaCliDriver</type>
-            <connect_order>5</connect_order>
+            <connect_order>7</connect_order>
             <COMPONENTS> </COMPONENTS>
         </QuaggaCliHost>
 
+        <QuaggaCliHost101>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>101</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost101>
+        <QuaggaCliHost102>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>102</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost102>
+        <QuaggaCliHost103>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>103</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost103>
+        <QuaggaCliHost104>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>104</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost104>
+        <QuaggaCliHost105>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>105</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost105>
+        <QuaggaCliHost106>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>106</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost106>
+        <QuaggaCliHost107>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>107</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost107>
+        <QuaggaCliHost108>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>108</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost108>
+        <QuaggaCliHost109>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>109</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost109>
+        <QuaggaCliHost110>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>110</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost110>
+        <QuaggaCliHost111>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>111</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost111>
+        <QuaggaCliHost112>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>112</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost112>
+        <QuaggaCliHost113>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>113</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost113>
+        <QuaggaCliHost114>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>114</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost114>
+        <QuaggaCliHost115>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>115</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost115>
+        <QuaggaCliHost116>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>116</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost116>
+        <QuaggaCliHost117>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>117</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost117>
+        <QuaggaCliHost118>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>118</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost118>
+        <QuaggaCliHost119>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>119</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost119>
+        <QuaggaCliHost120>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>120</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost120>
+        <QuaggaCliHost121>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>121</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost121>
+        <QuaggaCliHost122>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>122</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost122>
+        <QuaggaCliHost123>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>123</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost123>
+        <QuaggaCliHost124>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>124</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost124>
+        <QuaggaCliHost125>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>125</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost125>
+        <QuaggaCliHost126>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>126</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost126>
+        <QuaggaCliHost127>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>127</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost127>
+        <QuaggaCliHost128>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>128</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost128>
+        <QuaggaCliHost129>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>129</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost129>
+        <QuaggaCliHost130>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>130</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost130>
+        <QuaggaCliHost131>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>131</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost131>
+        <QuaggaCliHost132>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>132</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost132>
+        <QuaggaCliHost133>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>133</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost133>
+        <QuaggaCliHost134>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>134</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost134>
+        <QuaggaCliHost135>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>135</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost135>
+        <QuaggaCliHost136>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>136</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost136>
+        <QuaggaCliHost137>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>137</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost137>
+        <QuaggaCliHost138>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>138</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost138>
+        <QuaggaCliHost139>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>139</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost139>
+        <QuaggaCliHost140>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>140</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost140>
+        <QuaggaCliHost141>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>141</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost141>
+        <QuaggaCliHost142>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>142</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost142>
+        <QuaggaCliHost143>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>143</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost143>
+        <QuaggaCliHost144>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>144</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost144>
+        <QuaggaCliHost145>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>145</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost145>
+        <QuaggaCliHost146>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>146</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost146>
+        <QuaggaCliHost147>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>147</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost147>
+        <QuaggaCliHost148>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>148</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost148>
+        <QuaggaCliHost149>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>149</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost149>
+        <QuaggaCliHost150>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>150</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost150>
+        <QuaggaCliHost151>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>151</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost151>
+        <QuaggaCliHost152>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>152</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost152>
+        <QuaggaCliHost153>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>153</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost153>
+        <QuaggaCliHost154>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>154</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost154>
+        <QuaggaCliHost155>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>155</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost155>
+        <QuaggaCliHost156>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>156</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost156>
+        <QuaggaCliHost157>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>157</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost157>
+        <QuaggaCliHost158>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>158</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost158>
+        <QuaggaCliHost159>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>159</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost159>
+        <QuaggaCliHost160>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>160</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost160>
+        <QuaggaCliHost161>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>161</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost161>
+        <QuaggaCliHost162>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>162</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost162>
+        <QuaggaCliHost163>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>163</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost163>
+        <QuaggaCliHost164>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>164</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost164>
+        <QuaggaCliHost165>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>165</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost165>
+        <QuaggaCliHost166>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>166</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost166>
+        <QuaggaCliHost167>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>167</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost167>
+        <QuaggaCliHost168>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>168</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost168>
+        <QuaggaCliHost169>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>169</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost169>
+        <QuaggaCliHost170>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>170</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost170>
+        <QuaggaCliHost171>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>171</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost171>
+        <QuaggaCliHost172>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>172</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost172>
+        <QuaggaCliHost173>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>173</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost173>
+        <QuaggaCliHost174>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>174</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost174>
+        <QuaggaCliHost175>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>175</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost175>
+        <QuaggaCliHost176>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>176</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost176>
+        <QuaggaCliHost177>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>177</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost177>
+        <QuaggaCliHost178>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>178</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost178>
+        <QuaggaCliHost179>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>179</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost179>
+        <QuaggaCliHost180>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>180</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost180>
+        <QuaggaCliHost181>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>181</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost181>
+        <QuaggaCliHost182>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>182</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost182>
+        <QuaggaCliHost183>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>183</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost183>
+        <QuaggaCliHost184>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>184</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost184>
+        <QuaggaCliHost185>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>185</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost185>
+        <QuaggaCliHost186>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>186</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost186>
+        <QuaggaCliHost187>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>187</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost187>
+        <QuaggaCliHost188>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>188</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost188>
+        <QuaggaCliHost189>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>189</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost189>
+        <QuaggaCliHost190>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>190</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost190>
+        <QuaggaCliHost191>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>191</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost191>
+        <QuaggaCliHost192>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>192</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost192>
+        <QuaggaCliHost193>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>193</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost193>
+
+        <QuaggaCliHost194>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>194</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost194>
+        <QuaggaCliHost195>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>195</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost195>
+        <QuaggaCliHost196>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>196</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost196>
+        <QuaggaCliHost197>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>197</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost197>
+        <QuaggaCliHost198>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>198</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost198>
+        <QuaggaCliHost199>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>199</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost199>
+        <QuaggaCliHost200>
+            <host>127.0.0.1</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>QuaggaCliDriver</type>
+            <connect_order>200</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </QuaggaCliHost200>
+
+
     </COMPONENT>
 </TOPOLOGY>
+
diff --git a/TestON/tests/prevFuncNext/FuncNext.params b/TestON/tests/prevFuncNext/FuncNext.params
new file mode 100755
index 0000000..13a4691
--- /dev/null
+++ b/TestON/tests/prevFuncNext/FuncNext.params
@@ -0,0 +1,37 @@
+<PARAMS>
+    
+    <testcases>1,4,5,3</testcases>
+
+    #Environment variables
+    <ENV>
+        <cellName>driver_test</cellName>
+    </ENV>
+
+    <CTRL>
+        <ip1>10.128.20.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>
+</PARAMS>
diff --git a/TestON/tests/prevFuncNext/FuncNext.py b/TestON/tests/prevFuncNext/FuncNext.py
new file mode 100755
index 0000000..e556fa4
--- /dev/null
+++ b/TestON/tests/prevFuncNext/FuncNext.py
@@ -0,0 +1,311 @@
+
+#Testing the basic functionality of ONOS Next
+#For sanity and driver functionality excercises only.
+
+import time
+import sys
+import os
+import re
+import time
+
+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()
+        version_result = main.ONOSbench.get_version()
+
+        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_result = main.ONOSbench.set_cell(cell_name)
+        verify_result = main.ONOSbench.verify_cell()
+        cell_result = main.ONOS2.set_cell(cell_name)
+        #verify_result = main.ONOS2.verify_cell()
+        main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+        
+        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)
+        '''
+        main.step("Add point-to-point intents")
+        ptp_intent_result = main.ONOS2.add_point_intent(
+            devices_id_list[0], 1, devices_id_list[1], 2)
+        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)
+        '''
+
+        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 time
+        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")
+        '''for n in range(1,6):
+            result = main.Mininet1.compare_topo(MNTopo,
+                    main.ONOS1.get_json(main.params['CTRL']['ip'+str(n)]+":"+ \
+                        main.params['CTRL']['restPort'+str(n)]+main.params['TopoRest']))
+            if result == main.TRUE:
+                main.log.report("ONOS"+str(n) + " Topology matches MN Topology")
+            utilities.assert_equals(expect=main.TRUE,actual=result,
+                    onpass="ONOS" + str(n) + " Topology matches MN Topology",
+                    onfail="ONOS" + str(n) + " 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")
+        '''
+
+
diff --git a/TestON/tests/prevFuncNext/FuncNext.topo b/TestON/tests/prevFuncNext/FuncNext.topo
new file mode 100755
index 0000000..5d453a6
--- /dev/null
+++ b/TestON/tests/prevFuncNext/FuncNext.topo
@@ -0,0 +1,61 @@
+<TOPOLOGY>
+    <COMPONENT>
+
+        <ONOSbench>
+            <host>10.128.10.11</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosDriver</type>
+            <connect_order>1</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOSbench>
+
+        <ONOS1>
+            <host>10.128.10.11</host>
+            <user>sdn</user>
+            <password>sdn</password>
+            <type>OnosDriver</type>
+            <connect_order>2</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOS1>
+
+        <ONOS2>
+            <host>10.128.10.11</host>
+            <user>admin</user>
+            <password>onos_test</password>
+            <type>OnosCliDriver</type>
+            <connect_order>3</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOS2>
+
+        <Mininet1>
+            <host>10.128.10.11</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.10.11</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/prevFuncNext/__init__.py b/TestON/tests/prevFuncNext/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/TestON/tests/prevFuncNext/__init__.py