diff --git a/TestON/drivers/common/cli/emulator/mininetclidriver_orig.py b/TestON/drivers/common/cli/emulator/mininetclidriver_orig.py
deleted file mode 100644
index 2d7c0a5..0000000
--- a/TestON/drivers/common/cli/emulator/mininetclidriver_orig.py
+++ /dev/null
@@ -1,1937 +0,0 @@
-#!/usr/bin/env python
-"""
-Created on 26-Oct-2012
-
-author: Anil Kumar ( anilkumar.s@paxterrasolutions.com )
-
-
-TestON is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 of the License, or
-( at your option ) any later version.
-
-TestON is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with TestON.  If not, see <http://www.gnu.org/licenses/>.
-
-
-MininetCliDriver is the basic driver which will handle the Mininet functions
-
-Some functions rely on STS module. To install this,
-    git clone https://github.com/jhall11/sts.git
-
-Some functions rely on a modified version of Mininet. These functions
-should all be noted in the comments. To get this MN version run these commands
-from within your Mininet folder:
-    git remote add jhall11 https://github.com/jhall11/mininet.git
-    git fetch jhall11
-    git checkout -b dynamic_topo remotes/jhall11/dynamic_topo
-    git pull
-
-
-    Note that you may need to run 'sudo make develop' if your mnexec.c file
-changed when switching branches."""
-import pexpect
-import re
-import sys
-sys.path.append( "../" )
-from math import pow
-from drivers.common.cli.emulatordriver import Emulator
-
-
-class MininetCliDriver( Emulator ):
-
-    """
-       MininetCliDriver is the basic driver which will handle
-       the Mininet functions"""
-    def __init__( self ):
-        super( Emulator, self ).__init__()
-        self.handle = self
-        self.name = None
-        self.wrapped = sys.modules[ __name__ ]
-        self.flag = 0
-
-    def connect( self, **connectargs ):
-        """
-           Here the main is the TestON instance after creating
-           all the log handles."""
-        try:
-            for key in connectargs:
-                vars( self )[ key ] = connectargs[ key ]
-
-            self.name = self.options[ 'name' ]
-            self.handle = super(
-                MininetCliDriver,
-                self ).connect(
-                user_name=self.user_name,
-                ip_address=self.ip_address,
-                port=None,
-                pwd=self.pwd )
-
-            if self.handle:
-                main.log.info( "Connection successful to the host " +
-                               self.user_name +
-                               "@" +
-                               self.ip_address )
-                return main.TRUE
-            else:
-                main.log.error( "Connection failed to the host " +
-                                self.user_name +
-                                "@" +
-                                self.ip_address )
-                main.log.error( "Failed to connect to the Mininet CLI" )
-                return main.FALSE
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-        except Exception:
-            main.log.exception( self.name + ": Uncaught exception!" )
-            main.cleanup()
-            main.exit()
-
-    def startNet( self, topoFile='', args='', timeout=120 ):
-        """
-        Starts Mininet accepts a topology(.py) file and/or an optional
-        argument ,to start the mininet, as a parameter.
-        Returns main.TRUE if the mininet starts successfully and
-                main.FALSE otherwise
-        """
-        if self.handle:
-            # make sure old networks are cleaned up
-            main.log.info( self.name +
-                           ": Clearing any residual state or processes" )
-            self.handle.sendline( "sudo mn -c" )
-            i = self.handle.expect( [ 'password\sfor\s',
-                                      'Cleanup\scomplete',
-                                      pexpect.EOF,
-                                      pexpect.TIMEOUT ],
-                                    timeout )
-            if i == 0:
-                # Sudo asking for password
-                main.log.info( self.name + ": Sending sudo password" )
-                self.handle.sendline( self.pwd )
-                i = self.handle.expect( [ '%s:' % self.user,
-                                          '\$',
-                                          pexpect.EOF,
-                                          pexpect.TIMEOUT ],
-                                        timeout )
-            if i == 1:
-                main.log.info( self.name + ": Clean" )
-            elif i == 2:
-                main.log.error( self.name + ": Connection terminated" )
-            elif i == 3:  # timeout
-                main.log.error( self.name + ": Something while cleaning " +
-                                "Mininet took too long... " )
-            # Craft the string to start mininet
-            cmdString = "sudo "
-            if topoFile is None or topoFile == '':  # If no file is given
-                main.log.info( self.name + ": building fresh Mininet" )
-                cmdString += "mn "
-                if args is None or args == '':
-                    # If no args given, use args from .topo file
-                    args = self.options[ 'arg1' ] +\
-                                 " " + self.options[ 'arg2' ] +\
-                                 " --mac --controller " +\
-                                 self.options[ 'controller' ] + " " +\
-                                 self.options[ 'arg3' ]
-                else:  # else only use given args
-                    pass
-                    # TODO: allow use of topo args and method args?
-            else:  # Use given topology file
-                main.log.info( "Starting Mininet from topo file " + topoFile )
-                cmdString += topoFile + " "
-                if args is None:
-                    args = ''
-                    # TODO: allow use of args from .topo file?
-            cmdString += args
-            # Send the command and check if network started
-            self.handle.sendline( "" )
-            self.handle.expect( '\$' )
-            main.log.info( "Sending '" + cmdString + "' to " + self.name )
-            self.handle.sendline( cmdString )
-            while True:
-                i = self.handle.expect( [ 'mininet>',
-                                          'Exception',
-                                          '\*\*\*',
-                                          pexpect.EOF,
-                                          pexpect.TIMEOUT ],
-                                        timeout )
-                if i == 0:
-                    main.log.info( self.name + ": Mininet built" )
-                    return main.TRUE
-                elif i == 1:
-                    response = str( self.handle.before +
-                                    self.handle.after )
-                    self.handle.expect( '\$' )
-                    response += str( self.handle.before +
-                                    self.handle.after )
-                    main.log.error(
-                        self.name +
-                        ": Launching Mininet failed: " + response )
-                    return main.FALSE
-                elif i == 2:
-                    self.handle.expect( [ "\n",
-                                          pexpect.EOF,
-                                          pexpect.TIMEOUT ],
-                                        timeout )
-                    main.log.info( self.handle.before )
-                elif i == 3:
-                    main.log.error( self.name + ": Connection timeout" )
-                    return main.FALSE
-                elif i == 4:  # timeout
-                    main.log.error(
-                        self.name +
-                        ": Something took too long... " )
-                    return main.FALSE
-            # Why did we hit this part?
-            main.log.error( "startNet did not return correctly" )
-            return main.FASLE
-        else:  # if no handle
-            main.log.error( self.name + ": Connection failed to the host " +
-                            self.user_name + "@" + self.ip_address )
-            main.log.error( self.name + ": Failed to connect to the Mininet" )
-            return main.FALSE
-
-    def numSwitchesNlinks( self, topoType, depth, fanout ):
-        if topoType == 'tree':
-            # In tree topology, if fanout arg is not given, by default it is 2
-            if fanout is None:
-                fanout = 2
-            k = 0
-            count = 0
-            while( k <= depth - 1 ):
-                count = count + pow( fanout, k )
-                k = k + 1
-                numSwitches = count
-            while( k <= depth - 2 ):
-                # depth-2 gives you only core links and not considering
-                # edge links as seen by ONOS. If all the links including
-                # edge links are required, do depth-1
-                count = count + pow( fanout, k )
-                k = k + 1
-            numLinks = count * fanout
-            # print "num_switches for %s(%d,%d) = %d and links=%d" %(
-            # topoType,depth,fanout,numSwitches,numLinks )
-
-        elif topoType == 'linear':
-            # In linear topology, if fanout or numHostsPerSw is not given,
-            # by default it is 1
-            if fanout is None:
-                fanout = 1
-            numSwitches = depth
-            numHostsPerSw = fanout
-            totalNumHosts = numSwitches * numHostsPerSw
-            numLinks = totalNumHosts + ( numSwitches - 1 )
-            print "num_switches for %s(%d,%d) = %d and links=%d" %\
-                ( topoType, depth, fanout, numSwitches, numLinks )
-        topoDict = { "num_switches": int( numSwitches ),
-                     "num_corelinks": int( numLinks ) }
-        return topoDict
-
-    def calculateSwAndLinks( self ):
-        """
-            Calculate the number of switches and links in a topo."""
-        # TODO: combine this function and numSwitchesNlinks
-        argList = self.options[ 'arg1' ].split( "," )
-        topoArgList = argList[ 0 ].split( " " )
-        argList = map( int, argList[ 1: ] )
-        topoArgList = topoArgList[ 1: ] + argList
-
-        topoDict = self.numSwitchesNlinks( *topoArgList )
-        return topoDict
-
-    def pingall( self, timeout=300, shortCircuit=False, acceptableFailed=0):
-        """
-           Verifies the reachability of the hosts using pingall command.
-           Optional parameter timeout allows you to specify how long to
-           wait for pingall to complete
-           Optional:
-           timeout(seconds) - This is the pexpect timeout; The function will
-                              timeout if the amount of time between failed
-                              pings exceedes this time and pingall is still
-                              running
-           shortCircuit - Break the pingall based on the number of failed hosts
-                          ping
-           acceptableFailed - Set the number of acceptable failed pings for the
-                              function to still return main.TRUE
-           Returns:
-           main.TRUE if pingall completes with no pings dropped
-           otherwise main.FALSE"""
-        try:
-            if self.handle:
-                main.log.info(
-                    self.name +
-                    ": Checking reachabilty to the hosts using pingall" )
-                response = ""
-                failedPings = 0
-                returnValue = main.TRUE
-                self.handle.sendline( "pingall" )
-                while True:
-                    i = self.handle.expect( [ "mininet>","X",
-                                              pexpect.EOF,
-                                              pexpect.TIMEOUT ],
-                                              timeout )
-                    if i == 0:
-                        main.log.info( self.name + ": pingall finished")
-                        response += self.handle.before
-                        break
-                    elif i == 1:
-                        response += self.handle.before + self.handle.after
-                        failedPings = failedPings + 1
-                        if failedPings > acceptableFailed:
-                            returnValue = main.FALSE
-                            if shortCircuit:
-                                main.log.error( self.name +
-                                                ": Aborting pingall - "
-                                                + str( failedPings ) +
-                                                " pings failed" )
-                                break
-                    elif i == 2:
-                        main.log.error( self.name +
-                                        ": EOF exception found" )
-                        main.log.error( self.name + ":     " +
-                                        self.handle.before )
-                        main.cleanup()
-                        main.exit()
-                    elif i == 3:
-                        response += self.handle.before
-                        main.log.error( self.name +
-                                        ": TIMEOUT exception found" )
-                        main.log.error( self.name +
-                                        ":     " +
-                                        str( response ) )
-                        # NOTE: Send ctrl-c to make sure pingall is done
-                        self.handle.sendline( "\x03" )
-                        self.handle.expect( "Interrupt" )
-                        self.handle.expect( "mininet>" )
-                        break
-                pattern = "Results\:"
-                main.log.info( "Pingall output: " + str( response ) )
-                if re.search( pattern, response ):
-                    main.log.info( self.name + ": Pingall finished with "
-                                   + str( failedPings ) + " failed pings" )
-                    return returnValue
-                else:
-                    # NOTE: Send ctrl-c to make sure pingall is done
-                    self.handle.sendline( "\x03" )
-                    self.handle.expect( "Interrupt" )
-                    self.handle.expect( "mininet>" )
-                    return main.FALSE
-            else:
-                main.log.error( self.name + ": Connection failed to the host" )
-                main.cleanup()
-                main.exit()
-        except pexpect.TIMEOUT:
-            if response:
-                main.log.info( "Pingall output: " + str( response ) )
-            main.log.error( self.name + ": pexpect.TIMEOUT found" )
-            return main.FALSE
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-
-    def fpingHost( self, **pingParams ):
-        """
-           Uses the fping package for faster pinging...
-           *requires fping to be installed on machine running mininet"""
-        args = utilities.parse_args( [ "SRC", "TARGET" ], **pingParams )
-        command = args[ "SRC" ] + \
-            " fping -i 100 -t 20 -C 1 -q " + args[ "TARGET" ]
-        self.handle.sendline( command )
-        self.handle.expect(
-            [ args[ "TARGET" ], pexpect.EOF, pexpect.TIMEOUT ] )
-        self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
-        response = self.handle.before
-        if re.search( ":\s-", response ):
-            main.log.info( self.name + ": Ping fail" )
-            return main.FALSE
-        elif re.search( ":\s\d{1,2}\.\d\d", response ):
-            main.log.info( self.name + ": Ping good!" )
-            return main.TRUE
-        main.log.info( self.name + ": Install fping on mininet machine... " )
-        main.log.info( self.name + ": \n---\n" + response )
-        return main.FALSE
-
-    def pingHost( self, **pingParams ):
-        """
-           Ping from one mininet host to another
-           Currently the only supported Params: SRC and TARGET"""
-        args = utilities.parse_args( [ "SRC", "TARGET" ], **pingParams )
-        command = args[ "SRC" ] + " ping " + \
-            args[ "TARGET" ] + " -c 1 -i 1 -W 8"
-        try:
-            main.log.info( "Sending: " + command )
-            self.handle.sendline( command )
-            i = self.handle.expect( [ command, pexpect.TIMEOUT ] )
-            if i == 1:
-                main.log.error(
-                    self.name +
-                    ": timeout when waiting for response from mininet" )
-                main.log.error( "response: " + str( self.handle.before ) )
-            i = self.handle.expect( [ "mininet>", pexpect.TIMEOUT ] )
-            if i == 1:
-                main.log.error(
-                    self.name +
-                    ": timeout when waiting for response from mininet" )
-                main.log.error( "response: " + str( self.handle.before ) )
-            response = self.handle.before
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-        main.log.info( self.name + ": Ping Response: " + response )
-        if re.search( ',\s0\%\spacket\sloss', response ):
-            main.log.info( self.name + ": no packets lost, host is reachable" )
-            main.lastResult = main.TRUE
-            return main.TRUE
-        else:
-            main.log.error(
-                self.name +
-                ": PACKET LOST, HOST IS NOT REACHABLE" )
-            main.lastResult = main.FALSE
-            return main.FALSE
-
-    def checkIP( self, host ):
-        """
-           Verifies the host's ip configured or not."""
-        if self.handle:
-            try:
-                response = self.execute(
-                    cmd=host +
-                    " ifconfig",
-                    prompt="mininet>",
-                    timeout=10 )
-            except pexpect.EOF:
-                main.log.error( self.name + ": EOF exception found" )
-                main.log.error( self.name + ":     " + self.handle.before )
-                main.cleanup()
-                main.exit()
-
-            pattern = "inet\s(addr|Mask):([0-1]{1}[0-9]{1,2}|" +\
-                "2[0-4][0-9]|25[0-5]|[0-9]{1,2}).([0-1]{1}" +\
-                "[0-9]{1,2}|2[0-4][0-9]|25[0-5]|[0-9]{1,2})." +\
-                "([0-1]{1}[0-9]{1,2}|2[0-4][0-9]|25[0-5]|" +\
-                "[0-9]{1,2}).([0-1]{1}[0-9]{1,2}|2[0-4]" +\
-                "[0-9]|25[0-5]|[0-9]{1,2})"
-            # pattern = "inet addr:10.0.0.6"
-            if re.search( pattern, response ):
-                main.log.info( self.name + ": Host Ip configured properly" )
-                return main.TRUE
-            else:
-                main.log.error( self.name + ": Host IP not found" )
-                return main.FALSE
-        else:
-            main.log.error( self.name + ": Connection failed to the host" )
-
-    def verifySSH( self, **connectargs ):
-        # FIXME: Who uses this and what is the purpose? seems very specific
-        try:
-            response = self.execute(
-                cmd="h1 /usr/sbin/sshd -D&",
-                prompt="mininet>",
-                timeout=10 )
-            response = self.execute(
-                cmd="h4 /usr/sbin/sshd -D&",
-                prompt="mininet>",
-                timeout=10 )
-            for key in connectargs:
-                vars( self )[ key ] = connectargs[ key ]
-            response = self.execute(
-                cmd="xterm h1 h4 ",
-                prompt="mininet>",
-                timeout=10 )
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-        import time
-        time.sleep( 20 )
-        if self.flag == 0:
-            self.flag = 1
-            return main.FALSE
-        else:
-            return main.TRUE
-
-    def moveHost( self, host, oldSw, newSw, ):
-        """
-           Moves a host from one switch to another on the fly
-           Note: The intf between host and oldSw when detached
-                using detach(), will still show up in the 'net'
-                cmd, because switch.detach() doesn't affect switch.intfs[]
-                (which is correct behavior since the interfaces 
-                haven't moved).
-        """
-        if self.handle:
-            try:
-                # Bring link between oldSw-host down
-                cmd = "py net.configLinkStatus('" + oldSw + "'," + "'"+ host +\
-                      "'," + "'down')"
-                print "cmd1= ", cmd
-                response = self.execute( cmd=cmd,
-                                         prompt="mininet>",
-                                         timeout=10 )
-     
-                # Determine hostintf and Oldswitchintf
-                cmd = "px hintf,sintf = " + host + ".connectionsTo(" + oldSw +\
-                      ")[0]"
-                print "cmd2= ", cmd
-                self.handle.sendline( cmd )
-                self.handle.expect( "mininet>" )
-
-                # Determine ip and mac address of the host-oldSw interface
-                cmd = "px ipaddr = hintf.IP()"
-                print "cmd3= ", cmd
-                self.handle.sendline( cmd )
-                self.handle.expect( "mininet>" )
-
-                cmd = "px macaddr = hintf.MAC()"
-                print "cmd3= ", cmd
-                self.handle.sendline( cmd )
-                self.handle.expect( "mininet>" )
-                
-                # Detach interface between oldSw-host
-                cmd = "px " + oldSw + ".detach( sintf )"
-                print "cmd4= ", cmd
-                self.handle.sendline( cmd )
-                self.handle.expect( "mininet>" )
-
-                # Add link between host-newSw
-                cmd = "py net.addLink(" + host + "," + newSw + ")"
-                print "cmd5= ", cmd
-                self.handle.sendline( cmd )
-                self.handle.expect( "mininet>" )
- 
-                # Determine hostintf and Newswitchintf
-                cmd = "px hintf,sintf = " + host + ".connectionsTo(" + newSw +\
-                      ")[0]"
-                print "cmd6= ", cmd
-                self.handle.sendline( cmd )
-                self.handle.expect( "mininet>" )                 
-
-                # Attach interface between newSw-host
-                cmd = "px " + newSw + ".attach( sintf )"
-                print "cmd3= ", cmd
-                self.handle.sendline( cmd )
-                self.handle.expect( "mininet>" )
-                
-                # Set ipaddress of the host-newSw interface
-                cmd = "px " + host + ".setIP( ip = ipaddr, intf = hintf)"
-                print "cmd7 = ", cmd
-                self.handle.sendline( cmd )
-                self.handle.expect( "mininet>" )
-
-                # Set macaddress of the host-newSw interface
-                cmd = "px " + host + ".setMAC( mac = macaddr, intf = hintf)"
-                print "cmd8 = ", cmd
-                self.handle.sendline( cmd )
-                self.handle.expect( "mininet>" )
-                
-                cmd = "net"
-                print "cmd9 = ", cmd
-                self.handle.sendline( cmd )
-                self.handle.expect( "mininet>" )
-                print "output = ", self.handle.before
-
-                # Determine ipaddress of the host-newSw interface
-                cmd = host + " ifconfig"
-                print "cmd10= ", cmd
-                self.handle.sendline( cmd )
-                self.handle.expect( "mininet>" )
-                print "ifconfig o/p = ", self.handle.before
-                
-                return main.TRUE
-            except pexpect.EOF:
-                main.log.error( self.name + ": EOF exception found" )
-                main.log.error( self.name + ":     " + self.handle.before )
-                return main.FALSE
-
-    def changeIP( self, host, intf, newIP, newNetmask ):
-        """
-           Changes the ip address of a host on the fly
-           Ex: h2 ifconfig h2-eth0 10.0.1.2 netmask 255.255.255.0"""
-        if self.handle:
-            try:
-                cmd = host + " ifconfig " + intf + " " + \
-                    newIP + " " + 'netmask' + " " + newNetmask
-                self.handle.sendline( cmd )
-                self.handle.expect( "mininet>" )
-                response = self.handle.before
-                main.log.info( "response = " + response )
-                main.log.info(
-                    "Ip of host " +
-                    host +
-                    " changed to new IP " +
-                    newIP )
-                return main.TRUE
-            except pexpect.EOF:
-                main.log.error( self.name + ": EOF exception found" )
-                main.log.error( self.name + ":     " + self.handle.before )
-                return main.FALSE
-
-    def changeDefaultGateway( self, host, newGW ):
-        """
-           Changes the default gateway of a host
-           Ex: h1 route add default gw 10.0.1.2"""
-        if self.handle:
-            try:
-                cmd = host + " route add default gw " + newGW
-                self.handle.sendline( cmd )
-                self.handle.expect( "mininet>" )
-                response = self.handle.before
-                main.log.info( "response = " + response )
-                main.log.info(
-                    "Default gateway of host " +
-                    host +
-                    " changed to " +
-                    newGW )
-                return main.TRUE
-            except pexpect.EOF:
-                main.log.error( self.name + ": EOF exception found" )
-                main.log.error( self.name + ":     " + self.handle.before )
-                return main.FALSE
-
-    def addStaticMACAddress( self, host, GW, macaddr ):
-        """
-           Changes the mac address of a gateway host"""
-        if self.handle:
-            try:
-                # h1  arp -s 10.0.1.254 00:00:00:00:11:11
-                cmd = host + " arp -s " + GW + " " + macaddr
-                self.handle.sendline( cmd )
-                self.handle.expect( "mininet>" )
-                response = self.handle.before
-                main.log.info( "response = " + response )
-                main.log.info(
-                    "Mac address of gateway " +
-                    GW +
-                    " changed to " +
-                    macaddr )
-                return main.TRUE
-            except pexpect.EOF:
-                main.log.error( self.name + ": EOF exception found" )
-                main.log.error( self.name + ":     " + self.handle.before )
-                return main.FALSE
-
-    def verifyStaticGWandMAC( self, host ):
-        """
-           Verify if the static gateway and mac address assignment"""
-        if self.handle:
-            try:
-                # h1  arp -an
-                cmd = host + " arp -an "
-                self.handle.sendline( cmd )
-                self.handle.expect( "mininet>" )
-                response = self.handle.before
-                main.log.info( host + " arp -an = " + response )
-                return main.TRUE
-            except pexpect.EOF:
-                main.log.error( self.name + ": EOF exception found" )
-                main.log.error( self.name + ":     " + self.handle.before )
-                return main.FALSE
-
-    def getMacAddress( self, host ):
-        """
-           Verifies the host's ip configured or not."""
-        if self.handle:
-            try:
-                response = self.execute(
-                    cmd=host +
-                    " ifconfig",
-                    prompt="mininet>",
-                    timeout=10 )
-            except pexpect.EOF:
-                main.log.error( self.name + ": EOF exception found" )
-                main.log.error( self.name + ":     " + self.handle.before )
-                main.cleanup()
-                main.exit()
-
-            pattern = r'HWaddr\s([0-9A-F]{2}[:-]){5}([0-9A-F]{2})'
-            macAddressSearch = re.search( pattern, response, re.I )
-            macAddress = macAddressSearch.group().split( " " )[ 1 ]
-            main.log.info(
-                self.name +
-                ": Mac-Address of Host " +
-                host +
-                " is " +
-                macAddress )
-            return macAddress
-        else:
-            main.log.error( self.name + ": Connection failed to the host" )
-
-    def getInterfaceMACAddress( self, host, interface ):
-        """
-           Return the IP address of the interface on the given host"""
-        if self.handle:
-            try:
-                response = self.execute( cmd=host + " ifconfig " + interface,
-                                         prompt="mininet>", timeout=10 )
-            except pexpect.EOF:
-                main.log.error( self.name + ": EOF exception found" )
-                main.log.error( self.name + ":     " + self.handle.before )
-                main.cleanup()
-                main.exit()
-
-            pattern = r'HWaddr\s([0-9A-F]{2}[:-]){5}([0-9A-F]{2})'
-            macAddressSearch = re.search( pattern, response, re.I )
-            if macAddressSearch is None:
-                main.log.info( "No mac address found in %s" % response )
-                return main.FALSE
-            macAddress = macAddressSearch.group().split( " " )[ 1 ]
-            main.log.info(
-                "Mac-Address of " +
-                host +
-                ":" +
-                interface +
-                " is " +
-                macAddress )
-            return macAddress
-        else:
-            main.log.error( "Connection failed to the host" )
-
-    def getIPAddress( self, host ):
-        """
-           Verifies the host's ip configured or not."""
-        if self.handle:
-            try:
-                response = self.execute(
-                    cmd=host +
-                    " ifconfig",
-                    prompt="mininet>",
-                    timeout=10 )
-            except pexpect.EOF:
-                main.log.error( self.name + ": EOF exception found" )
-                main.log.error( self.name + ":     " + self.handle.before )
-                main.cleanup()
-                main.exit()
-
-            pattern = "inet\saddr:(\d+\.\d+\.\d+\.\d+)"
-            ipAddressSearch = re.search( pattern, response )
-            main.log.info(
-                self.name +
-                ": IP-Address of Host " +
-                host +
-                " is " +
-                ipAddressSearch.group( 1 ) )
-            return ipAddressSearch.group( 1 )
-        else:
-            main.log.error( self.name + ": Connection failed to the host" )
-
-    def getSwitchDPID( self, switch ):
-        """
-           return the datapath ID of the switch"""
-        if self.handle:
-            cmd = "py %s.dpid" % switch
-            try:
-                response = self.execute(
-                    cmd=cmd,
-                    prompt="mininet>",
-                    timeout=10 )
-            except pexpect.EOF:
-                main.log.error( self.name + ": EOF exception found" )
-                main.log.error( self.name + ":     " + self.handle.before )
-                main.cleanup()
-                main.exit()
-            pattern = r'^(?P<dpid>\w)+'
-            result = re.search( pattern, response, re.MULTILINE )
-            if result is None:
-                main.log.info(
-                    "Couldn't find DPID for switch %s, found: %s" %
-                    ( switch, response ) )
-                return main.FALSE
-            return str( result.group( 0 ) ).lower()
-        else:
-            main.log.error( "Connection failed to the host" )
-
-    def getDPID( self, switch ):
-        if self.handle:
-            self.handle.sendline( "" )
-            self.expect( "mininet>" )
-            cmd = "py %s.dpid" % switch
-            try:
-                response = self.execute(
-                    cmd=cmd,
-                    prompt="mininet>",
-                    timeout=10 )
-                self.handle.expect( "mininet>" )
-                response = self.handle.before
-                return response
-            except pexpect.EOF:
-                main.log.error( self.name + ": EOF exception found" )
-                main.log.error( self.name + ":     " + self.handle.before )
-                main.cleanup()
-                main.exit()
-
-    def getInterfaces( self, node ):
-        """
-           return information dict about interfaces connected to the node"""
-        if self.handle:
-            cmd = 'py "\\n".join(["name=%s,mac=%s,ip=%s,enabled=%s"' +\
-                ' % (i.name, i.MAC(), i.IP(), i.isUp())'
-            cmd += ' for i in %s.intfs.values()])' % node
-            try:
-                response = self.execute(
-                    cmd=cmd,
-                    prompt="mininet>",
-                    timeout=10 )
-            except pexpect.EOF:
-                main.log.error( self.name + ": EOF exception found" )
-                main.log.error( self.name + ":     " + self.handle.before )
-                main.cleanup()
-                main.exit()
-            return response
-        else:
-            main.log.error( "Connection failed to the node" )
-
-    def dump( self ):
-        main.log.info( self.name + ": Dump node info" )
-        try:
-            response = self.execute(
-                cmd='dump',
-                prompt='mininet>',
-                timeout=10 )
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-        return response
-
-    def intfs( self ):
-        main.log.info( self.name + ": List interfaces" )
-        try:
-            response = self.execute(
-                cmd='intfs',
-                prompt='mininet>',
-                timeout=10 )
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-        return response
-
-    def net( self ):
-        main.log.info( self.name + ": List network connections" )
-        try:
-            response = self.execute( cmd='net', prompt='mininet>', timeout=10 )
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-        return response
-
-    def iperf( self, host1, host2 ):
-        main.log.info(
-            self.name +
-            ": Simple iperf TCP test between two hosts" )
-        try:
-            cmd1 = 'iperf ' + host1 + " " + host2
-            self.handle.sendline( cmd1 )
-            self.handle.expect( "mininet>" )
-            response = self.handle.before
-            if re.search( 'Results:', response ):
-                main.log.info( self.name + ": iperf test successful" )
-                return main.TRUE
-            else:
-                main.log.error( self.name + ": iperf test failed" )
-                return main.FALSE
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-
-    def iperfudp( self ):
-        main.log.info(
-            self.name +
-            ": Simple iperf TCP test between two " +
-            "(optionally specified) hosts" )
-        try:
-            response = self.execute(
-                cmd='iperfudp',
-                prompt='mininet>',
-                timeout=10 )
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-        return response
-
-    def nodes( self ):
-        main.log.info( self.name + ": List all nodes." )
-        try:
-            response = self.execute(
-                cmd='nodes',
-                prompt='mininet>',
-                timeout=10 )
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-        return response
-
-    def pingpair( self ):
-        main.log.info( self.name + ": Ping between first two hosts" )
-        try:
-            response = self.execute(
-                cmd='pingpair',
-                prompt='mininet>',
-                timeout=20 )
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-
-        if re.search( ',\s0\%\spacket\sloss', response ):
-            main.log.info( self.name + ": Ping between two hosts SUCCESSFUL" )
-            main.lastResult = main.TRUE
-            return main.TRUE
-        else:
-            main.log.error( self.name + ": PACKET LOST, HOSTS NOT REACHABLE" )
-            main.lastResult = main.FALSE
-            return main.FALSE
-
-    def link( self, **linkargs ):
-        """
-           Bring link( s ) between two nodes up or down"""
-        args = utilities.parse_args( [ "END1", "END2", "OPTION" ], **linkargs )
-        end1 = args[ "END1" ] if args[ "END1" ] is not None else ""
-        end2 = args[ "END2" ] if args[ "END2" ] is not None else ""
-        option = args[ "OPTION" ] if args[ "OPTION" ] is not None else ""
-        main.log.info(
-            "Bring link between '" +
-            end1 +
-            "' and '" +
-            end2 +
-            "' '" +
-            option +
-            "'" )
-        command = "link " + \
-            str( end1 ) + " " + str( end2 ) + " " + str( option )
-        try:
-            self.handle.sendline( command )
-            self.handle.expect( "mininet>" )
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-        return main.TRUE
-
-    def yank( self, **yankargs ):
-        """
-           yank a mininet switch interface to a host"""
-        main.log.info( 'Yank the switch interface attached to a host' )
-        args = utilities.parse_args( [ "SW", "INTF" ], **yankargs )
-        sw = args[ "SW" ] if args[ "SW" ] is not None else ""
-        intf = args[ "INTF" ] if args[ "INTF" ] is not None else ""
-        command = "py " + str( sw ) + '.detach("' + str(intf) + '")'
-        try:
-            response = self.execute(
-                cmd=command,
-                prompt="mininet>",
-                timeout=10 )
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-        return main.TRUE
-
-    def plug( self, **plugargs ):
-        """
-           plug the yanked mininet switch interface to a switch"""
-        main.log.info( 'Plug the switch interface attached to a switch' )
-        args = utilities.parse_args( [ "SW", "INTF" ], **plugargs )
-        sw = args[ "SW" ] if args[ "SW" ] is not None else ""
-        intf = args[ "INTF" ] if args[ "INTF" ] is not None else ""
-        command = "py " + str( sw ) + '.attach("' + str(intf) + '")'
-        try:
-            response = self.execute(
-                cmd=command,
-                prompt="mininet>",
-                timeout=10 )
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-        return main.TRUE
-
-    def dpctl( self, **dpctlargs ):
-        """
-           Run dpctl command on all switches."""
-        main.log.info( 'Run dpctl command on all switches' )
-        args = utilities.parse_args( [ "CMD", "ARGS" ], **dpctlargs )
-        cmd = args[ "CMD" ] if args[ "CMD" ] is not None else ""
-        cmdargs = args[ "ARGS" ] if args[ "ARGS" ] is not None else ""
-        command = "dpctl " + cmd + " " + str( cmdargs )
-        try:
-            response = self.execute(
-                cmd=command,
-                prompt="mininet>",
-                timeout=10 )
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-        return main.TRUE
-
-    def getVersion( self ):
-        #FIXME: What uses this? This should be refactored to get
-        #       version from MN and not some other file
-        fileInput = path + '/lib/Mininet/INSTALL'
-        version = super( Mininet, self ).getVersion()
-        pattern = 'Mininet\s\w\.\w\.\w\w*'
-        for line in open( fileInput, 'r' ).readlines():
-            result = re.match( pattern, line )
-            if result:
-                version = result.group( 0 )
-        return version
-
-    def getSwController( self, sw ):
-        """
-        Parameters:
-            sw: The name of an OVS switch. Example "s1"
-        Return:
-            The output of the command from the mininet cli
-            or main.FALSE on timeout"""
-        command = "sh ovs-vsctl get-controller " + str( sw )
-        try:
-            response = self.execute(
-                cmd=command,
-                prompt="mininet>",
-                timeout=10 )
-            if response:
-                return response
-            else:
-                return main.FALSE
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-
-    def assignSwController( self, **kwargs ):
-        """
-           count is only needed if there is more than 1 controller"""
-        args = utilities.parse_args( [ "COUNT" ], **kwargs )
-        count = args[ "COUNT" ] if args != {} else 1
-
-        argstring = "SW"
-        for j in range( count ):
-            argstring = argstring + ",IP" + \
-                str( j + 1 ) + ",PORT" + str( j + 1 )
-        args = utilities.parse_args( argstring.split( "," ), **kwargs )
-
-        sw = args[ "SW" ] if args[ "SW" ] is not None else ""
-        ptcpA = int( args[ "PORT1" ] ) + \
-            int( sw ) if args[ "PORT1" ] is not None else ""
-        ptcpB = "ptcp:" + str( ptcpA ) if ptcpA != "" else ""
-
-        command = "sh ovs-vsctl set-controller s" + \
-            str( sw ) + " " + ptcpB + " "
-        for j in range( count ):
-            i = j + 1
-            args = utilities.parse_args(
-                [ "IP" + str( i ), "PORT" + str( i ) ], **kwargs )
-            ip = args[
-                "IP" +
-                str( i ) ] if args[
-                "IP" +
-                str( i ) ] is not None else ""
-            port = args[
-                "PORT" +
-                str( i ) ] if args[
-                "PORT" +
-                str( i ) ] is not None else ""
-            tcp = "tcp:" + str( ip ) + ":" + str( port ) + \
-                " " if ip != "" else ""
-            command = command + tcp
-        try:
-            self.execute( cmd=command, prompt="mininet>", timeout=5 )
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-        except Exception:
-            main.log.exception( self.name + ": Uncaught exception!" )
-            main.cleanup()
-            main.exit()
-
-    def deleteSwController( self, sw ):
-        """
-           Removes the controller target from sw"""
-        command = "sh ovs-vsctl del-controller " + str( sw )
-        try:
-            response = self.execute(
-                cmd=command,
-                prompt="mininet>",
-                timeout=10 )
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-        else:
-            main.log.info( response )
-
-    def addSwitch( self, sw, **kwargs ):
-        """
-        adds a switch to the mininet topology
-        NOTE: This uses a custom mn function. MN repo should be on
-            dynamic_topo branch
-        NOTE: cannot currently specify what type of switch
-        required params:
-            sw = name of the new switch as a string
-        optional keywords:
-            dpid = "dpid"
-        returns: main.FALSE on an error, else main.TRUE
-        """
-        dpid = kwargs.get( 'dpid', '' )
-        command = "addswitch " + str( sw ) + " " + str( dpid )
-        try:
-            response = self.execute(
-                cmd=command,
-                prompt="mininet>",
-                timeout=10 )
-            if re.search( "already exists!", response ):
-                main.log.warn( response )
-                return main.FALSE
-            elif re.search( "Error", response ):
-                main.log.warn( response )
-                return main.FALSE
-            elif re.search( "usage:", response ):
-                main.log.warn( response )
-                return main.FALSE
-            else:
-                return main.TRUE
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-
-    def delSwitch( self, sw ):
-        """
-        delete a switch from the mininet topology
-        NOTE: This uses a custom mn function. MN repo should be on
-            dynamic_topo branch
-        required params:
-            sw = name of the switch as a string
-        returns: main.FALSE on an error, else main.TRUE"""
-        command = "delswitch " + str( sw )
-        try:
-            response = self.execute(
-                cmd=command,
-                prompt="mininet>",
-                timeout=10 )
-            if re.search( "no switch named", response ):
-                main.log.warn( response )
-                return main.FALSE
-            elif re.search( "Error", response ):
-                main.log.warn( response )
-                return main.FALSE
-            elif re.search( "usage:", response ):
-                main.log.warn( response )
-                return main.FALSE
-            else:
-                return main.TRUE
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-
-    def addLink( self, node1, node2 ):
-        """
-           add a link to the mininet topology
-           NOTE: This uses a custom mn function. MN repo should be on
-                dynamic_topo branch
-           NOTE: cannot currently specify what type of link
-           required params:
-           node1 = the string node name of the first endpoint of the link
-           node2 = the string node name of the second endpoint of the link
-           returns: main.FALSE on an error, else main.TRUE"""
-        command = "addlink " + str( node1 ) + " " + str( node2 )
-        try:
-            response = self.execute(
-                cmd=command,
-                prompt="mininet>",
-                timeout=10 )
-            if re.search( "doesnt exist!", response ):
-                main.log.warn( response )
-                return main.FALSE
-            elif re.search( "Error", response ):
-                main.log.warn( response )
-                return main.FALSE
-            elif re.search( "usage:", response ):
-                main.log.warn( response )
-                return main.FALSE
-            else:
-                return main.TRUE
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-
-    def delLink( self, node1, node2 ):
-        """
-           delete a link from the mininet topology
-           NOTE: This uses a custom mn function. MN repo should be on
-                dynamic_topo branch
-           required params:
-           node1 = the string node name of the first endpoint of the link
-           node2 = the string node name of the second endpoint of the link
-           returns: main.FALSE on an error, else main.TRUE"""
-        command = "dellink " + str( node1 ) + " " + str( node2 )
-        try:
-            response = self.execute(
-                cmd=command,
-                prompt="mininet>",
-                timeout=10 )
-            if re.search( "no node named", response ):
-                main.log.warn( response )
-                return main.FALSE
-            elif re.search( "Error", response ):
-                main.log.warn( response )
-                return main.FALSE
-            elif re.search( "usage:", response ):
-                main.log.warn( response )
-                return main.FALSE
-            else:
-                return main.TRUE
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-
-    def addHost( self, hostname, **kwargs ):
-        """
-        Add a host to the mininet topology
-        NOTE: This uses a custom mn function. MN repo should be on
-            dynamic_topo branch
-        NOTE: cannot currently specify what type of host
-        required params:
-            hostname = the string hostname
-        optional key-value params
-            switch = "switch name"
-            returns: main.FALSE on an error, else main.TRUE
-        """
-        switch = kwargs.get( 'switch', '' )
-        command = "addhost " + str( hostname ) + " " + str( switch )
-        try:
-            response = self.execute(
-                cmd=command,
-                prompt="mininet>",
-                timeout=10 )
-            if re.search( "already exists!", response ):
-                main.log.warn( response )
-                return main.FALSE
-            elif re.search( "doesnt exists!", response ):
-                main.log.warn( response )
-                return main.FALSE
-            elif re.search( "Error", response ):
-                main.log.warn( response )
-                return main.FALSE
-            elif re.search( "usage:", response ):
-                main.log.warn( response )
-                return main.FALSE
-            else:
-                return main.TRUE
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-
-    def delHost( self, hostname ):
-        """
-           delete a host from the mininet topology
-           NOTE: This uses a custom mn function. MN repo should be on
-               dynamic_topo branch
-           NOTE: this uses a custom mn function
-           required params:
-           hostname = the string hostname
-           returns: main.FALSE on an error, else main.TRUE"""
-        command = "delhost " + str( hostname )
-        try:
-            response = self.execute(
-                cmd=command,
-                prompt="mininet>",
-                timeout=10 )
-            if re.search( "no host named", response ):
-                main.log.warn( response )
-                return main.FALSE
-            elif re.search( "Error", response ):
-                main.log.warn( response )
-                return main.FALSE
-            elif re.search( "usage:", response ):
-                main.log.warn( response )
-                return main.FALSE
-            else:
-                return main.TRUE
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-
-    def disconnect( self ):
-        """
-        Called at the end of the test to stop the mininet and
-        disconnect the handle.
-        """
-        self.handle.sendline('')
-        i = self.handle.expect( [ 'mininet>', pexpect.EOF, pexpect.TIMEOUT ],
-                                timeout=2)
-        if i == 0:
-            self.stopNet()
-        elif i == 1:
-            return main.TRUE
-        response = main.TRUE
-        # print "Disconnecting Mininet"
-        if self.handle:
-            self.handle.sendline( "exit" )
-            self.handle.expect( "exit" )
-            self.handle.expect( "(.*)" )
-        else:
-            main.log.error( "Connection failed to the host" )
-        return response
-
-    def stopNet( self, fileName = "", timeout=5):
-        """
-        Stops mininet.
-        Returns main.TRUE if the mininet successfully stops and
-                main.FALSE if the pexpect handle does not exist.
-
-        Will cleanup and exit the test if mininet fails to stop
-        """
-
-        main.log.info( self.name + ": Stopping mininet..." )
-        response = ''
-        if self.handle:
-            try:
-                self.handle.sendline("")
-                i = self.handle.expect( [ 'mininet>',
-                                          '\$',
-                                          pexpect.EOF,
-                                          pexpect.TIMEOUT ],
-                                        timeout )
-                if i == 0:
-                    main.log.info( "Exiting mininet..." )
-               
-                response = self.execute(
-                    cmd="exit",
-                    prompt="(.*)",
-                    timeout=120 )
-                main.log.info( self.name + ": Stopped")
-                self.handle.sendline( "sudo mn -c" )
-                response = main.TRUE
-                
-                if i == 1:
-                    main.log.info( " Mininet trying to exit while not " +
-                                   "in the mininet prompt" )
-                elif i == 2:
-                    main.log.error( "Something went wrong exiting mininet" )
-                elif i == 3:  # timeout
-                    main.log.error( "Something went wrong exiting mininet " +
-                                    "TIMEOUT" )
-                
-                if fileName:
-                    self.handle.sendline("")
-                    self.handle.expect('\$')
-                    self.handle.sendline("sudo kill -9 \`ps -ef | grep \""+ fileName +"\" | grep -v grep | awk '{print $2}'\`")
-            except pexpect.EOF:
-                main.log.error( self.name + ": EOF exception found" )
-                main.log.error( self.name + ":     " + self.handle.before )
-                main.cleanup()
-                main.exit()
-        else:
-            main.log.error( self.name + ": Connection failed to the host" )
-            response = main.FALSE
-        return response
-
-    def arping( self, src, dest, destmac ):
-        self.handle.sendline( '' )
-        self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
-
-        self.handle.sendline( src + ' arping ' + dest )
-        try:
-            self.handle.expect( [ destmac, pexpect.EOF, pexpect.TIMEOUT ] )
-            main.log.info( self.name + ": ARP successful" )
-            self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
-            return main.TRUE
-        except Exception:
-            main.log.warn( self.name + ": ARP FAILURE" )
-            self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
-            return main.FALSE
-
-    def decToHex( self, num ):
-        return hex( num ).split( 'x' )[ 1 ]
-
-    def getSwitchFlowCount( self, switch ):
-        """
-           return the Flow Count of the switch"""
-        if self.handle:
-            cmd = "sh ovs-ofctl dump-aggregate %s" % switch
-            try:
-                response = self.execute(
-                    cmd=cmd,
-                    prompt="mininet>",
-                    timeout=10 )
-            except pexpect.EOF:
-                main.log.error( self.name + ": EOF exception found" )
-                main.log.error( self.name + "     " + self.handle.before )
-                main.cleanup()
-                main.exit()
-            pattern = "flow_count=(\d+)"
-            result = re.search( pattern, response, re.MULTILINE )
-            if result is None:
-                main.log.info(
-                    "Couldn't find flows on switch %s, found: %s" %
-                    ( switch, response ) )
-                return main.FALSE
-            return result.group( 1 )
-        else:
-            main.log.error( "Connection failed to the Mininet host" )
-
-    def checkFlows( self, sw, dumpFormat=None ):
-        if dumpFormat:
-            command = "sh ovs-ofctl -F " + \
-                dumpFormat + " dump-flows " + str( sw )
-        else:
-            command = "sh ovs-ofctl dump-flows " + str( sw )
-        try:
-            response = self.execute(
-                cmd=command,
-                prompt="mininet>",
-                timeout=10 )
-            return response
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-
-    def startTcpdump( self, filename, intf="eth0", port="port 6633" ):
-        """
-           Runs tpdump on an interface and saves the file
-           intf can be specified, or the default eth0 is used"""
-        try:
-            self.handle.sendline( "" )
-            self.handle.expect( "mininet>" )
-            self.handle.sendline(
-                "sh sudo tcpdump -n -i " +
-                intf +
-                " " +
-                port +
-                " -w " +
-                filename.strip() +
-                "  &" )
-            self.handle.sendline( "" )
-            i = self.handle.expect( [ 'No\ssuch\device',
-                                      'listening\son',
-                                      pexpect.TIMEOUT,
-                                      "mininet>" ],
-                                    timeout=10 )
-            main.log.warn( self.handle.before + self.handle.after )
-            self.handle.sendline( "" )
-            self.handle.expect( "mininet>" )
-            if i == 0:
-                main.log.error(
-                    self.name +
-                    ": tcpdump - No such device exists. " +
-                    "tcpdump attempted on: " +
-                    intf )
-                return main.FALSE
-            elif i == 1:
-                main.log.info( self.name + ": tcpdump started on " + intf )
-                return main.TRUE
-            elif i == 2:
-                main.log.error(
-                    self.name +
-                    ": tcpdump command timed out! Check interface name," +
-                    " given interface was: " +
-                    intf )
-                return main.FALSE
-            elif i == 3:
-                main.log.info( self.name + ": " + self.handle.before )
-                return main.TRUE
-            else:
-                main.log.error( self.name + ": tcpdump - unexpected response" )
-            return main.FALSE
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-        except Exception:
-            main.log.exception( self.name + ": Uncaught exception!" )
-            main.cleanup()
-            main.exit()
-
-    def stopTcpdump( self ):
-        """
-            pkills tcpdump"""
-        try:
-            self.handle.sendline( "sh sudo pkill tcpdump" )
-            self.handle.expect( "mininet>" )
-            self.handle.sendline( "" )
-            self.handle.expect( "mininet>" )
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-        except Exception:
-            main.log.exception( self.name + ": Uncaught exception!" )
-            main.cleanup()
-            main.exit()
-
-    def compareSwitches( self, topo, switchesJson ):
-        """
-           Compare mn and onos switches
-           topo: sts TestONTopology object
-            switchesJson: parsed json object from the onos devices api
-
-           This uses the sts TestONTopology object"""
-        # main.log.debug( "Switches_json string: ", switchesJson )
-        output = { "switches": [] }
-        # iterate through the MN topology and pull out switches and and port
-        # info
-        for switch in topo.graph.switches:
-            ports = []
-            for port in switch.ports.values():
-                ports.append( { 'of_port': port.port_no,
-                                'mac': str( port.hw_addr ).replace( '\'', '' ),
-                                'name': port.name } )
-            output[ 'switches' ].append( {
-                "name": switch.name,
-                "dpid": str( switch.dpid ).zfill( 16 ),
-                "ports": ports } )
-
-        # print "mn"
-        # print json.dumps( output,
-        #                   sort_keys=True,
-        #                   indent=4,
-        #                   separators=( ',', ': ' ) )
-        # print "onos"
-        # print json.dumps( switchesJson,
-        #                   sort_keys=True,
-        #                   indent=4,
-        #                   separators=( ',', ': ' ) )
-
-        # created sorted list of dpid's in MN and ONOS for comparison
-        mnDPIDs = []
-        for switch in output[ 'switches' ]:
-            mnDPIDs.append( switch[ 'dpid' ].lower() )
-        mnDPIDs.sort()
-        # print "List of Mininet switch DPID's"
-        # print mnDPIDs
-        if switchesJson == "":  # if rest call fails
-            main.log.error(
-                self.name +
-                ".compare_switches(): Empty JSON object given from ONOS" )
-            return main.FALSE
-        onos = switchesJson
-        onosDPIDs = []
-        for switch in onos:
-            if switch[ 'available' ]:
-                onosDPIDs.append(
-                    switch[ 'id' ].replace(
-                        ":",
-                        '' ).replace(
-                        "of",
-                        '' ).lower() )
-            # else:
-                # print "Switch is unavailable:"
-                # print switch
-        onosDPIDs.sort()
-        # print "List of ONOS switch DPID's"
-        # print onosDPIDs
-
-        if mnDPIDs != onosDPIDs:
-            switchResults = main.FALSE
-            main.log.report( "Switches in MN but not in ONOS:" )
-            list1 = [ switch for switch in mnDPIDs if switch not in onosDPIDs ]
-            main.log.report( str( list1 ) )
-            main.log.report( "Switches in ONOS but not in MN:" )
-            list2 = [ switch for switch in onosDPIDs if switch not in mnDPIDs ]
-            main.log.report( str( list2 ) )
-        else:  # list of dpid's match in onos and mn
-            switchResults = main.TRUE
-        return switchResults
-
-    def comparePorts( self, topo, portsJson ):
-        """
-        Compare mn and onos ports
-        topo: sts TestONTopology object
-        portsJson: parsed json object from the onos ports api
-
-        Dependencies:
-            1. This uses the sts TestONTopology object
-            2. numpy - "sudo pip install numpy"
-
-        """
-        # FIXME: this does not look for extra ports in ONOS, only checks that
-        # ONOS has what is in MN
-        from numpy import uint64
-        portsResults = main.TRUE
-        output = { "switches": [] }
-        # iterate through the MN topology and pull out switches and and port
-        # info
-        for switch in topo.graph.switches:
-            ports = []
-            for port in switch.ports.values():
-                # print port.hw_addr.toStr( separator='' )
-                tmpPort = { 'of_port': port.port_no,
-                            'mac': str( port.hw_addr ).replace( '\'', '' ),
-                            'name': port.name,
-                            'enabled': port.enabled }
-
-                ports.append( tmpPort )
-            tmpSwitch = { 'name': switch.name,
-                          'dpid': str( switch.dpid ).zfill( 16 ),
-                          'ports': ports }
-
-            output[ 'switches' ].append( tmpSwitch )
-
-        # PORTS
-        for mnSwitch in output[ 'switches' ]:
-            mnPorts = []
-            onosPorts = []
-            switchResult = main.TRUE
-            for port in mnSwitch[ 'ports' ]:
-                if port[ 'enabled' ]:
-                    mnPorts.append( port[ 'of_port' ] )
-            for onosSwitch in portsJson:
-                # print "Iterating through a new switch as seen by ONOS"
-                # print onosSwitch
-                if onosSwitch[ 'device' ][ 'available' ]:
-                    if onosSwitch[ 'device' ][ 'id' ].replace(
-                            ':',
-                            '' ).replace(
-                            "of",
-                            '' ) == mnSwitch[ 'dpid' ]:
-                        for port in onosSwitch[ 'ports' ]:
-                            if port[ 'isEnabled' ]:
-                                if port[ 'port' ] == 'local':
-                                    # onosPorts.append( 'local' )
-                                    onosPorts.append( long( uint64( -2 ) ) )
-                                else:
-                                    onosPorts.append( int( port[ 'port' ] ) )
-                        break
-            mnPorts.sort( key=float )
-            onosPorts.sort( key=float )
-            # print "\nPorts for Switch %s:" % ( mnSwitch[ 'name' ] )
-            # print "\tmn_ports[] = ", mnPorts
-            # print "\tonos_ports[] = ", onosPorts
-            mnPortsLog = mnPorts
-            onosPortsLog = onosPorts
-            mnPorts = [ x for x in mnPorts ]
-            onosPorts = [ x for x in onosPorts ]
-
-            # TODO: handle other reserved port numbers besides LOCAL
-            # NOTE: Reserved ports
-            # Local port: -2 in Openflow, ONOS shows 'local', we store as
-            # long( uint64( -2 ) )
-            for mnPort in mnPortsLog:
-                if mnPort in onosPorts:
-                    # don't set results to true here as this is just one of
-                    # many checks and it might override a failure
-                    mnPorts.remove( mnPort )
-                    onosPorts.remove( mnPort )
-                # NOTE: OVS reports this as down since there is no link
-                #      So ignoring these for now
-                # TODO: Come up with a better way of handling these
-                if 65534 in mnPorts:
-                    mnPorts.remove( 65534 )
-                if long( uint64( -2 ) ) in onosPorts:
-                    onosPorts.remove( long( uint64( -2 ) ) )
-            if len( mnPorts ):  # the ports of this switch don't match
-                switchResult = main.FALSE
-                main.log.warn( "Ports in MN but not ONOS: " + str( mnPorts ) )
-            if len( onosPorts ):  # the ports of this switch don't match
-                switchResult = main.FALSE
-                main.log.warn(
-                    "Ports in ONOS but not MN: " +
-                    str( onosPorts ) )
-            if switchResult == main.FALSE:
-                main.log.report(
-                    "The list of ports for switch %s(%s) does not match:" %
-                    ( mnSwitch[ 'name' ], mnSwitch[ 'dpid' ] ) )
-                main.log.warn( "mn_ports[]  =  " + str( mnPortsLog ) )
-                main.log.warn( "onos_ports[] = " + str( onosPortsLog ) )
-            portsResults = portsResults and switchResult
-        return portsResults
-
-    def compareLinks( self, topo, linksJson ):
-        """
-           Compare mn and onos links
-           topo: sts TestONTopology object
-           linksJson: parsed json object from the onos links api
-
-           This uses the sts TestONTopology object"""
-        # FIXME: this does not look for extra links in ONOS, only checks that
-        #        ONOS has what is in MN
-        output = { "switches": [] }
-        onos = linksJson
-        # iterate through the MN topology and pull out switches and and port
-        # info
-        for switch in topo.graph.switches:
-            # print "Iterating though switches as seen by Mininet"
-            # print switch
-            ports = []
-            for port in switch.ports.values():
-                # print port.hw_addr.toStr( separator='' )
-                ports.append( { 'of_port': port.port_no,
-                                'mac': str( port.hw_addr ).replace( '\'', '' ),
-                                'name': port.name } )
-            output[ 'switches' ].append( {
-                "name": switch.name,
-                "dpid": str( switch.dpid ).zfill( 16 ),
-                "ports": ports } )
-        # LINKS
-
-        mnLinks = [
-            link for link in topo.patch_panel.network_links if (
-                link.port1.enabled and link.port2.enabled ) ]
-        if 2 * len( mnLinks ) == len( onos ):
-            linkResults = main.TRUE
-        else:
-            linkResults = main.FALSE
-            main.log.report(
-                "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
-        # NOTE: Will currently only show mn links as down if they are
-        #       cut through STS. We can either do everything through STS or
-        #       wait for upNetworkLinks and downNetworkLinks to be
-        #       fully implemented.
-        for link in mnLinks:
-            # print "Link: %s" % link
-            # TODO: Find a more efficient search method
-            node1 = None
-            port1 = None
-            node2 = None
-            port2 = None
-            firstDir = main.FALSE
-            secondDir = main.FALSE
-            for switch in output[ 'switches' ]:
-                # print "Switch: %s" % switch[ 'name' ]
-                if switch[ 'name' ] == link.node1.name:
-                    node1 = switch[ 'dpid' ]
-                    for port in switch[ 'ports' ]:
-                        if str( port[ 'name' ] ) == str( link.port1 ):
-                            port1 = port[ 'of_port' ]
-                    if node1 is not None and node2 is not None:
-                        break
-                if switch[ 'name' ] == link.node2.name:
-                    node2 = switch[ 'dpid' ]
-                    for port in switch[ 'ports' ]:
-                        if str( port[ 'name' ] ) == str( link.port2 ):
-                            port2 = port[ 'of_port' ]
-                    if node1 is not None and node2 is not None:
-                        break
-
-            for onosLink in onos:
-                onosNode1 = onosLink[ 'src' ][ 'device' ].replace(
-                    ":",
-                    '' ).replace(
-                    "of",
-                    '' )
-                onosNode2 = onosLink[ 'dst' ][ 'device' ].replace(
-                    ":",
-                    '' ).replace(
-                    "of",
-                    '' )
-                onosPort1 = onosLink[ 'src' ][ 'port' ]
-                onosPort2 = onosLink[ 'dst' ][ 'port' ]
-
-                # check onos link from node1 to node2
-                if str( onosNode1 ) == str( node1 ) and str(
-                        onosNode2 ) == str( node2 ):
-                    if int( onosPort1 ) == int( port1 ) and int(
-                            onosPort2 ) == int( port2 ):
-                        firstDir = main.TRUE
-                    else:
-                        main.log.warn(
-                            'The port numbers do not match for ' +
-                            str( link ) +
-                            ' between ONOS and MN. When checking ONOS for ' +
-                            'link %s/%s -> %s/%s' %
-                            ( node1,
-                              port1,
-                              node2,
-                              port2 ) +
-                            ' ONOS has the values %s/%s -> %s/%s' %
-                            ( onosNode1,
-                              onosPort1,
-                              onosNode2,
-                              onosPort2 ) )
-
-                # check onos link from node2 to node1
-                elif ( str( onosNode1 ) == str( node2 ) and
-                        str( onosNode2 ) == str( node1 ) ):
-                    if ( int( onosPort1 ) == int( port2 )
-                            and int( onosPort2 ) == int( port1 ) ):
-                        secondDir = main.TRUE
-                    else:
-                        main.log.warn(
-                            'The port numbers do not match for ' +
-                            str( link ) +
-                            ' between ONOS and MN. When checking ONOS for ' +
-                            'link %s/%s -> %s/%s' %
-                            ( node2,
-                              port2,
-                              node1,
-                              port1 ) +
-                            ' ONOS has the values %s/%s -> %s/%s' %
-                            ( onosNode2,
-                              onosPort2,
-                              onosNode1,
-                              onosPort1 ) )
-                else:  # this is not the link you're looking for
-                    pass
-            if not firstDir:
-                main.log.report(
-                    'ONOS does not have the link %s/%s -> %s/%s' %
-                    ( node1, port1, node2, port2 ) )
-            if not secondDir:
-                main.log.report(
-                    'ONOS does not have the link %s/%s -> %s/%s' %
-                    ( node2, port2, node1, port1 ) )
-            linkResults = linkResults and firstDir and secondDir
-        return linkResults
-
-    def compareHosts( self, topo, hostsJson ):
-        """
-           Compare mn and onos Hosts.
-           Since Mininet hosts are quiet, ONOS will only know of them when they
-           speak. For this reason, we will only check that the hosts in ONOS
-           stores are in Mininet, and not vice versa.
-           topo: sts TestONTopology object
-           hostsJson: parsed json object from the onos hosts api
-
-           This uses the sts TestONTopology object"""
-        import json
-        hostResults = main.TRUE
-        hosts = []
-        # iterate through the MN topology and pull out hosts
-        for mnHost in topo.graph.hosts:
-            interfaces = []
-            for intf in mnHost.interfaces:
-                interfaces.append( {
-                    "name": intf.name,  # str
-                    "ips": [ str( ip ) for ip in intf.ips ],  # list of IPAddrs
-                    # hw_addr is of type EthAddr, Not JSON serializable
-                    "hw_addr": str( intf.hw_addr ) } )
-            hosts.append( {
-                "name": mnHost.name,  # str
-                "interfaces": interfaces  } )  # list
-        for onosHost in hostsJson:
-            onosMAC = onosHost[ 'mac' ].lower()
-            match = False
-            for mnHost in hosts:
-                for mnIntf in mnHost[ 'interfaces' ]:
-                    if onosMAC == mnIntf[ 'hw_addr' ].lower() :
-                        match = True
-                        for ip in mnIntf[ 'ips' ]:
-                            if ip in onosHost[ 'ips' ]:
-                                pass  # all is well
-                            else:
-                                # misssing ip
-                                main.log.error( "ONOS host " + onosHost[ 'id' ]
-                                                + " has a different IP than " +
-                                                "the Mininet host." )
-                                output = json.dumps(
-                                                    onosHost,
-                                                    sort_keys=True,
-                                                    indent=4,
-                                                    separators=( ',', ': ' ) )
-                                main.log.info( output )
-                                hostResults = main.FALSE
-            if not match:
-                hostResults = main.FALSE
-                main.log.error( "ONOS host " + onosHost[ 'id' ] + " has no " +
-                                "corresponding Mininet host." )
-                output = json.dumps( onosHost,
-                                     sort_keys=True,
-                                     indent=4,
-                                     separators=( ',', ': ' ) )
-                main.log.info( output )
-        return hostResults
-
-    def getHosts( self ):
-        """
-           Returns a list of all hosts
-           Don't ask questions just use it"""
-        self.handle.sendline( "" )
-        self.handle.expect( "mininet>" )
-
-        self.handle.sendline( "py [ host.name for host in net.hosts ]" )
-        self.handle.expect( "mininet>" )
-
-        handlePy = self.handle.before
-        handlePy = handlePy.split( "]\r\n", 1 )[ 1 ]
-        handlePy = handlePy.rstrip()
-
-        self.handle.sendline( "" )
-        self.handle.expect( "mininet>" )
-
-        hostStr = handlePy.replace( "]", "" )
-        hostStr = hostStr.replace( "'", "" )
-        hostStr = hostStr.replace( "[", "" )
-        hostList = hostStr.split( "," )
-
-        return hostList
-
-    def update( self ):
-        """
-           updates the port address and status information for
-           each port in mn"""
-        # TODO: Add error checking. currently the mininet command has no output
-        main.log.info( "Updating MN port information" )
-        try:
-            self.handle.sendline( "" )
-            self.handle.expect( "mininet>" )
-
-            self.handle.sendline( "update" )
-            self.handle.expect( "update" )
-            self.handle.expect( "mininet>" )
-
-            self.handle.sendline( "" )
-            self.handle.expect( "mininet>" )
-
-            return main.TRUE
-        except pexpect.EOF:
-            main.log.error( self.name + ": EOF exception found" )
-            main.log.error( self.name + ":     " + self.handle.before )
-            main.cleanup()
-            main.exit()
-
-if __name__ != "__main__":
-    import sys
-    sys.modules[ __name__ ] = MininetCliDriver()
diff --git a/TestON/drivers/common/cli/onosclidriver.py b/TestON/drivers/common/cli/onosclidriver.py
index 0052d40..c4e2e42 100644
--- a/TestON/drivers/common/cli/onosclidriver.py
+++ b/TestON/drivers/common/cli/onosclidriver.py
@@ -1821,9 +1821,11 @@
                 for flow in device.get( 'flows' ):
                     if flow.get( 'state' ) != 'ADDED' and flow.get( 'state' ) != \
                             'PENDING_ADD':
+
                         main.log.info( self.name + ": flow Id: " +
-                                       flow.get( 'groupId' ) +
-                                       " | state:" + flow.get( 'state' ) )
+                                       str( flow.get( 'groupId' ) ) +
+                                       " | state:" +
+                                       str( flow.get( 'state' ) ) )
                         returnValue = main.FALSE
 
             return returnValue
diff --git a/TestON/tests/FuncIntent/Dependency/FuncIntentFunction.py b/TestON/tests/FuncIntent/Dependency/FuncIntentFunction.py
index 3f41180..1d7f227 100644
--- a/TestON/tests/FuncIntent/Dependency/FuncIntentFunction.py
+++ b/TestON/tests/FuncIntent/Dependency/FuncIntentFunction.py
@@ -477,10 +477,12 @@
                 #print "len devices = ", len( devices )
                 #print "len ports = ", len( ports )
                 return main.FALSE
-        for i in range( len( devices ) ):
-            macsDict[ devices[ i ] ] = macs[ i ]
         else:
             main.log.info( "Device Ports are not specified" )
+        if macs:
+            for i in range( len( devices ) ):
+                macsDict[ devices[ i ] ] = macs[ i ]
+
     elif hostNames and not devices and main.hostsData:
         devices = []
         main.log.info( "singleToMultiIntent function is using main.hostsData" ) 
@@ -642,7 +644,7 @@
             Verify add-multi-to-single-intent
         Steps:
             - Get device ids | ports
-            - Add single to multi point intents
+            - Add multi to single point intents
             - Check intents
             - Verify flows
             - Ping hosts
@@ -706,13 +708,14 @@
                 #print "len devices = ", len( devices )
                 #print "len ports = ", len( ports )
                 return main.FALSE
-        for i in range( len( devices ) ):
-            macsDict[ devices[ i ] ] = macs[ i ]
         else:
             main.log.info( "Device Ports are not specified" )
+        if macs:
+            for i in range( len( devices ) ):
+                macsDict[ devices[ i ] ] = macs[ i ]
     elif hostNames and not devices and main.hostsData:
         devices = []
-        main.log.info( "singleToMultiIntent function is using main.hostsData" ) 
+        main.log.info( "multiToSingleIntent function is using main.hostsData" ) 
         for host in hostNames:
                devices.append( main.hostsData.get( host ).get( 'location' ) )
                macsDict[ main.hostsData.get( host ).get( 'location' ) ] = \
@@ -736,7 +739,7 @@
     devicesCopy = copy.copy( devices )
     if ports:
         portsCopy = copy.copy( ports )
-    main.log.info( itemName + ": Adding single point to multi point intents" )
+    main.log.info( itemName + ": Adding multi point to single point intents" )
     # Adding bidirectional point  intents
     for i in range( len( devices ) ):
         egressDevice = devicesCopy[ i ]
diff --git a/TestON/tests/FuncIntent/FuncIntent.py b/TestON/tests/FuncIntent/FuncIntent.py
index c107847..fac3fd6 100644
--- a/TestON/tests/FuncIntent/FuncIntent.py
+++ b/TestON/tests/FuncIntent/FuncIntent.py
@@ -325,7 +325,7 @@
                                  onfail="DUALSTACK1: Add host intent failed" )
 
         stepResult = main.TRUE
-        main.step( "DUALSTACK2: Add host intents between h1 and h9" )
+        main.step( "DUALSTACK2: Add host intents between h1 and h11" )
         stepResult = main.wrapper.hostIntent( main,
                                               name='DUALSTACK2',
                                               host1='h1',
@@ -341,6 +341,18 @@
                                  onfail="DUALSTACK2: Add host intent failed" )
 
         stepResult = main.TRUE
+        main.step( "1HOP: Add host intents between h1 and h3" )
+        stepResult = main.wrapper.hostIntent( main,
+                                              name='1HOP',
+                                              host1='h1',
+                                              host2='h3' )
+
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="1HOP: Add host intent" +
+                                        " successful",
+                                 onfail="1HOP: Add host intent failed" )
+
         main.step( "VLAN1: Add vlan host intents between h4 and h12" )
         stepResult = main.wrapper.hostIntent( main,
                                               name='VLAN1',
@@ -407,7 +419,26 @@
         main.case( "Add point intents between 2 devices" )
 
         stepResult = main.TRUE
-        main.step( "IPV4: Add point intents between h1 and h9" )
+        # No option point intents
+        main.step( "NOOPTION: Add point intents between h1 and h9" )
+        stepResult = main.wrapper.pointIntent(
+                                       main,
+                                       name="NOOPTION",
+                                       host1="h1",
+                                       host2="h9",
+                                       deviceId1="of:0000000000000005/1",
+                                       deviceId2="of:0000000000000006/1",
+                                       sw1="s5",
+                                       sw2="s2",
+                                       expectedLink=18 )
+
+        stepResult = main.TRUE
+        main.step( "NOOPTION: Add point intents between h1 and h9" )
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="NOOPTION: Add point intent successful",
+                                 onfail="NOOPTION: Add point intent failed" )
+
         stepResult = main.wrapper.pointIntent(
                                        main,
                                        name="IPV4",
@@ -496,6 +527,19 @@
                                  onpass="VLAN: Add point intent successful",
                                  onfail="VLAN: Add point intent failed" )
 
+        stepResult = main.TRUE
+        main.step( "1HOP: Add point intents between h1 and h3" )
+        stepResult = main.wrapper.hostIntent( main,
+                                              name='1HOP',
+                                              host1='h1',
+                                              host2='h3' )
+
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="1HOP: Add point intent" +
+                                        " successful",
+                                 onfail="1HOP: Add point intent failed" )
+
     def CASE1003( self, main ):
         """
             Add single point to multi point intents
@@ -524,11 +568,31 @@
         main.case( "Add single point to multi point intents between devices" )
 
         stepResult = main.TRUE
-        main.step( "IPV4: Add single point to multi point intents" )
         hostNames = [ 'h8', 'h16', 'h24' ]
         devices = [ 'of:0000000000000005/8', 'of:0000000000000006/8', \
                     'of:0000000000000007/8' ]
         macs = [ '00:00:00:00:00:08', '00:00:00:00:00:10', '00:00:00:00:00:18' ]
+
+        main.step( "NOOPTION: Add single point to multi point intents" )
+        stepResult = main.wrapper.singleToMultiIntent(
+                                         main,
+                                         name="NOOPTION",
+                                         hostNames=hostNames,
+                                         devices=devices,
+                                         sw1="s5",
+                                         sw2="s2",
+                                         expectedLink=18 )
+
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="NOOPTION: Successfully added single "
+                                        + " point to multi point intents",
+                                 onfail="NOOPTION: Failed to add single point" +
+                                        " to multi point intents" )
+
+
+
+        main.step( "IPV4: Add single point to multi point intents" )
         stepResult = main.wrapper.singleToMultiIntent(
                                          main,
                                          name="IPV4",
@@ -564,8 +628,8 @@
 
         utilities.assert_equals( expect=main.TRUE,
                                  actual=stepResult,
-                                 onpass="IPV4_2: Successfully added single point"
-                                        + " to multi point intents",
+                                 onpass="IPV4_2: Successfully added single "
+                                        + " point to multi point intents",
                                  onfail="IPV4_2: Failed to add single point" +
                                         " to multi point intents" )
         stepResult = main.TRUE
@@ -626,11 +690,30 @@
         main.case( "Add multi point to single point intents between devices" )
 
         stepResult = main.TRUE
-        main.step( "IPV4: Add multi point to single point intents" )
         hostNames = [ 'h8', 'h16', 'h24' ]
         devices = [ 'of:0000000000000005/8', 'of:0000000000000006/8', \
                     'of:0000000000000007/8' ]
         macs = [ '00:00:00:00:00:08', '00:00:00:00:00:10', '00:00:00:00:00:18' ]
+
+        main.step( "NOOPTION: Add multi point to single point intents" )
+        stepResult = main.wrapper.multiToSingleIntent(
+                                         main,
+                                         name="NOOPTION",
+                                         hostNames=hostNames,
+                                         devices=devices,
+                                         sw1="s5",
+                                         sw2="s2",
+                                         expectedLink=18 )
+
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="NOOPTION: Successfully added multi "
+                                        + " point to single point intents",
+                                 onfail="NOOPTION: Failed to add multi point" +
+                                        " to single point intents" )
+
+
+        main.step( "IPV4: Add multi point to single point intents" )
         stepResult = main.wrapper.multiToSingleIntent(
                                          main,
                                          name="IPV4",
diff --git a/TestON/tests/PingallExample/PingallExample.params b/TestON/tests/PingallExample/PingallExample.params
index 6d23beb..1e4cfc1 100644
--- a/TestON/tests/PingallExample/PingallExample.params
+++ b/TestON/tests/PingallExample/PingallExample.params
@@ -1,61 +1,12 @@
 <PARAMS>
-    <testcases>1,2,25,26</testcases>
+    <testcases>1,2,3</testcases>
     <ENV>
-        <cellName>test1</cellName>
+        <cellName>SingleHA</cellName>
     </ENV>
-    <Git>False</Git>
+    <Git>xe</Git>
 
     <CTRL>
-        <ip1>10.128.40.70</ip1>
+        <ip1>10.128.30.11</ip1>
         <port1>6633</port1>
     </CTRL>
-
-    <VPING>
-        <source1V1>
-            <vhost>h1</vhost>
-            <vintf>eth0</vintf>
-        </source1V1>
-        <source1V2>
-            <vhost>h3</vhost>
-            <vintf>eth0</vintf>
-        </source1V2>
-        <source1Vnone>
-            <vhost>h4</vhost>
-            <vintf>eth0</vintf>
-        </source1Vnone>
-        <source1V1Int>
-            <vhost>h6</vhost>
-            <vintf>eth0</vintf>
-        </source1V1Int>
-
-        <target1V1>
-            <vhost>h7</vhost>
-            <vintf>eth0</vintf>
-        </target1V1>
-        <target2V1>
-            <vhost>h8</vhost>
-            <vintf>eth0</vintf>
-        </target2V1>
-        <target1V2>
-            <vhost>h9</vhost>
-            <vintf>eth0</vintf>
-        </target1V2>
-
-        <target1Vnone>
-            <vhost>h11</vhost>
-            <vintf>eth0</vintf>
-        </target1Vnone>
-        <target1V1Int>
-            <vhost>h14</vhost>
-            <vintf>eth0</vintf>
-        </target1V1Int>
-
-    </VPING>
-    <VTAGS>
-        <tag1>100</tag1>
-        <tag2>200</tag2>
-        <tag3>300</tag3>
-        <tag4>400</tag4>
-    </VTAGS>
-
 </PARAMS>
diff --git a/TestON/tests/PingallExample/PingallExample.py b/TestON/tests/PingallExample/PingallExample.py
index c8d02a8..c03b0f1 100644
--- a/TestON/tests/PingallExample/PingallExample.py
+++ b/TestON/tests/PingallExample/PingallExample.py
@@ -163,176 +163,9 @@
         main.log.info( "Time for pingall: %2f seconds" % ( time2 - time1 ) )
 
         # uninstall onos-app-fwd
-        # main.step( "Deactivate reactive forwarding app" )
-        #main.ONOScli1.deactivateApp( "org.onosproject.fwd" )
+        main.step( "Deactivate reactive forwarding app" )
+        main.ONOScli1.deactivateApp( "org.onosproject.fwd" )
 
         utilities.assert_equals( expect=main.TRUE, actual=pingResult,
                                  onpass="All hosts are reachable",
                                  onfail="Some pings failed" )
-
-    def CASE25( self, main ):
-        """
-           Activate fwd app
-           Ping selected hosts
-           Assign selected hosts vlans
-           Ping to test vlans 
-           Deactivate fwd app
-        """
-        import time
-
-        main.log.report( "This testcase creates different vlan hosts " +
-                         " and verifies that only hosts that belong " + 
-                         " to the same vlan can ping each others")
-        main.log.report( "___________________________________________________" )
-        main.case( "Creating vlans and performing ping between hosts" )
-
-        main.step( "Activate reactive forwarding app" )
-        main.ONOScli1.activateApp( "org.onosproject.fwd" )
-
-        main.step( "Activate reactive forwarding app" )
-        main.ONOScli1.activateApp( "org.onosproject.fwd" )
-
-        main.step( "Verify host pinging in Mininet before creating vlans" )
-        source1V1 = main.params[ 'VPING' ][ 'source1V1' ]['vhost']
-        source1V2 = main.params[ 'VPING' ][ 'source1V2' ]['vhost']
-        source1Vnone = main.params[ 'VPING' ][ 'source1Vnone' ]['vhost']
-        target1V1 = main.params[ 'VPING' ][ 'target1V1' ]['vhost']
-        target2V1 = main.params[ 'VPING' ][ 'target2V1' ]['vhost']
-        target1V2 = main.params[ 'VPING' ][ 'target1V2' ]['vhost']
-        target1Vnone = main.params[ 'VPING' ][ 'target1Vnone' ]['vhost']
-
-        targetIP1V1 = main.Mininet1.getIPAddress(target1V1)
-        targetIP2V1 = main.Mininet1.getIPAddress(target2V1)
-        targetIP1V2 =  main.Mininet1.getIPAddress(target1V2)
-        targetIP1Vnone =  main.Mininet1.getIPAddress(target1Vnone)
-        
-        for i in range(0,2):
-            ping1V1 = main.Mininet1.pingHost( src = source1V1, target = targetIP1V1)
-            ping2V1 = main.Mininet1.pingHost( src = source1V1, target = targetIP2V1)
-            ping1V2 = main.Mininet1.pingHost( src = source1V2, target = targetIP1V2)
-            pingV1V2 = main.Mininet1.pingHost( src = source1V1, target = targetIP1V2)
-            pingV2V1 = main.Mininet1.pingHost( src = source1V2, target = targetIP1V1)
-            pingV1Vnone = main.Mininet1.pingHost ( src = source1V1, target = targetIP1Vnone)
-            pingVnoneV2 =  main.Mininet1.pingHost ( src = source1Vnone, target = targetIP1V2)
-
-        pingResultBeforeVlan = ping1V1 and ping2V1 and ping1V2 and pingV1V2 \
-                             and pingV2V1 and pingV1Vnone and pingVnoneV2
-
-        
-        if pingResultBeforeVlan == main.TRUE:
-            main.log.report("Ping succeeded before vlans are created")
-
-            main.step( "Create vlan hosts in mininet" )
-            v1Tag = main.params[ 'VTAGS' ][ 'tag1' ]
-            v2Tag = main.params[ 'VTAGS' ][ 'tag2' ]        
-            intfSource1V1 = source1V1 + "-" + main.params[ 'VPING' ][ 'source1V1' ][ 'vintf' ]
-            intfSource1V2 = source1V2 + "-" + main.params[ 'VPING' ][ 'source1V2' ][ 'vintf' ]
-            intfTarget1V1 = target1V1 + "-" + main.params[ 'VPING' ][ 'target1V1' ][ 'vintf' ]
-            intfTarget2V1 = target2V1 + "-" + main.params[ 'VPING' ][ 'target2V1' ][ 'vintf' ]
-            intfTarget1V2 = target1V2 + "-" + main.params[ 'VPING' ][ 'target1V2' ][ 'vintf' ]
-        
-            main.Mininet1.assignVLAN(source1V1, intfSource1V1, v1Tag)
-            main.Mininet1.assignVLAN(target1V1, intfTarget1V1, v1Tag)
-            main.Mininet1.assignVLAN(target2V1, intfTarget2V1, v1Tag)
-            main.Mininet1.assignVLAN(source1V2, intfSource1V2, v2Tag)
-            main.Mininet1.assignVLAN(target1V2, intfTarget1V2, v2Tag)
-        
-            main.step( "Verify host pinging in Mininet after creating vlans" )
-        
-            ping1V1 = main.Mininet1.pingHost( src = source1V1, target = targetIP1V1)
-            ping2V1 = main.Mininet1.pingHost( src = source1V1, target = targetIP2V1)
-            ping1V2 = main.Mininet1.pingHost( src = source1V2, target = targetIP1V2)
-            pingV1V2 = main.Mininet1.pingHost( src = source1V1, target = targetIP1V2)
-            pingV2V1 = main.Mininet1.pingHost( src = source1V2, target = targetIP1V1)
-            pingV1Vnone = main.Mininet1.pingHost ( src = source1V1, target = targetIP1Vnone)
-            pingVnoneV2 =  main.Mininet1.pingHost ( src = source1Vnone, target = targetIP1V2)
-
-
-            pingExpectedTrue = ping1V1 and ping2V1 and ping1V2
-            pingResultAfterVlan = pingExpectedTrue and not pingV1V2 \
-                   and not pingV2V1 and not pingV1Vnone and not pingVnoneV2
-
-            if pingResultAfterVlan == main.TRUE:
-                main.log.report("Ping results are as expected after vlans are created")
-                testCaseResult = main.TRUE
-            if pingResultAfterVlan == main.FALSE:
-                main.log.report("Ping results are not expected after vlans are created")
-                testCaseResult = main.FALSE
-
-            case25Result = testCaseResult
-            utilities.assert_equals( expect=main.TRUE, actual=case25Result,
-                                 onpass="Vlan verification is successfull",
-                                 onfail="Vlan verification failed" )
-        if pingResultBeforeVlan == main.FALSE:
-            main.log.report("Ping failed before vlans are created")
-            case25Result = main.FALSE
-            utilities.assert_equals( expect=main.TRUE, actual=case25Result,
-                                 onpass="Test case 25 can be verified",
-                                 onfail="Test case 25 cannot be verified because " + 
-                                   "there are ping failures before assigning host vlans" )
-        
-        main.step( "Deactivate reactive forwarding app" )
-        main.ONOScli1.deactivateApp( "org.onosproject.fwd" )
-            
-    def CASE26( self, main ):
-        """
-           This test case verifies that hosts belonging to the same vlan,
-           can ping each other with proactive forwarding (after adding host intent):
-              - Deactivate app fwd
-              - Assign vlan tag to selected hosts
-              - Add host intent between the selected hosts
-              - Ping the selected hosts to verify proactive forwarding with vlan hosts
-        """
-        import time
-
-        main.log.report( "This testcase creates vlan hosts, " +
-                         " add host intent, " + 
-                         " then ping the hosts")
-        main.log.report( "___________________________________________________" )
-        main.case( "Creating vlans and performing ping between hosts" )
-
-        main.step( "Deactivate reactive forwarding app" )
-        main.ONOScli1.deactivateApp( "org.onosproject.fwd" )
-        
-        main.step( "Assign vlan hosts in mininet" )
-        
-        source1V1 = main.params[ 'VPING' ][ 'source1V1Int' ]['vhost']
-        target1V1 = main.params[ 'VPING' ][ 'target1V1Int' ]['vhost']
- 
-        intfSource1V1 = source1V1 + "-" + main.params[ 'VPING' ][ 'source1V1Int' ][ 'vintf' ]
-        intfTarget1V1 = target1V1 + "-" + main.params[ 'VPING' ][ 'target1V1Int' ][ 'vintf' ]
-        
-        vTag = main.params[ 'VTAGS' ][ 'tag3' ]        
-
-        main.Mininet1.assignVLAN(source1V1, intfSource1V1, vTag)
-        main.Mininet1.assignVLAN(target1V1, intfTarget1V1, vTag)
-        
-        main.step( "Add host intent" )
-        mac1 = main.Mininet1.getMacAddress(source1V1)
-        mac2 = main.Mininet1.getMacAddress(target1V1)
-        id1 = mac1 + "/" + vTag
-        id2 = mac2 + "/" + vTag
-        hthIntentResult = main.ONOScli1.addHostIntent( id1 , id2 )
-        if hthIntentResult:       
-            main.step( "Ping hosts after installing host intent" )
-            #time.sleep(10)
-            targetIPV1 = main.Mininet1.getIPAddress(target1V1)
-            for i in range(0,3):
-                ping1V1 = main.Mininet1.pingHost( src = source1V1, target = targetIPV1)
-            
-            if ping1V1 == main.TRUE:
-                main.log.report(" Vlan hosts can ping each other successfully "+
-                                  " after add host intent.")
-            
-            if ping1V1 == main.FALSE:
-                main.log.report("Vlan hosts failed to ping each other "+ 
-                                 " after add host intent. ")
-              
-        else:
-            main.log.report(" add host intent failed between vlan hosts ")
-
-        case26Result = hthIntentResult and ping1V1
-        utilities.assert_equals( expect=main.TRUE, actual=case26Result,
-                                 onpass="Test case 26 is successfull",
-                                 onfail="Test case 26 has failed" )
-
diff --git a/TestON/tests/PingallExample/PingallExample.topo b/TestON/tests/PingallExample/PingallExample.topo
index 8a9f99f..3eda540 100644
--- a/TestON/tests/PingallExample/PingallExample.topo
+++ b/TestON/tests/PingallExample/PingallExample.topo
@@ -2,18 +2,16 @@
     <COMPONENT>
 
         <ONOSbench>
-            <host>10.128.40.70</host>
+            <host>10.128.30.10</host>
             <user>admin</user>
             <password></password>
             <type>OnosDriver</type>
             <connect_order>1</connect_order>
-            <COMPONENTS>
-		<home>~/ONOS</home>
-	    </COMPONENTS>
+            <COMPONENTS> </COMPONENTS>
         </ONOSbench>
 
         <ONOScli1>
-            <host>10.128.40.70</host>
+            <host>10.128.30.10</host>
             <user>admin</user>
             <password></password>
             <type>OnosCliDriver</type>
@@ -22,7 +20,7 @@
         </ONOScli1>
 
         <ONOS1>
-            <host>10.128.40.70</host>
+            <host>10.128.30.11</host>
             <user>admin</user>
             <password></password>
             <type>OnosDriver</type>
@@ -31,7 +29,7 @@
         </ONOS1>
 
         <Mininet1>
-            <host>10.128.40.70</host>
+            <host>10.128.30.9</host>
             <user>admin</user>
             <password></password>
             <type>MininetCliDriver</type>
diff --git a/TestON/tests/PingallExample/PingallExample_orig.py b/TestON/tests/PingallExample/PingallExample_orig.py
deleted file mode 100644
index c03b0f1..0000000
--- a/TestON/tests/PingallExample/PingallExample_orig.py
+++ /dev/null
@@ -1,171 +0,0 @@
-"""
-Description: This test is an example of a simple single node ONOS test
-
-List of test cases:
-CASE1: Compile ONOS and push it to the test machine
-CASE2: Assign mastership to controller
-CASE3: Pingall
-"""
-class PingallExample:
-
-    def __init__( self ):
-        self.default = ''
-
-    def CASE1( self, main ):
-        """
-           CASE1 is to compile ONOS and push it to the test machines
-
-           Startup sequence:
-           git pull
-           mvn clean install
-           onos-package
-           cell <name>
-           onos-verify-cell
-           onos-install -f
-           onos-wait-for-start
-        """
-        desc = "ONOS Single node cluster restart HA test - initialization"
-        main.log.report( desc )
-        main.case( "Setting up test environment" )
-
-        # load some vairables from the params file
-        PULLCODE = False
-        if main.params[ 'Git' ] == 'True':
-            PULLCODE = True
-        cellName = main.params[ 'ENV' ][ 'cellName' ]
-
-        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
-
-        main.step( "Applying cell variable to environment" )
-        cellResult = main.ONOSbench.setCell( cellName )
-        verifyResult = main.ONOSbench.verifyCell()
-
-        main.log.report( "Uninstalling ONOS" )
-        main.ONOSbench.onosUninstall( ONOS1Ip )
-
-        cleanInstallResult = main.TRUE
-        gitPullResult = main.TRUE
-
-        main.step( "Compiling the latest version of ONOS" )
-        if PULLCODE:
-            main.step( "Git checkout and pull master" )
-            main.ONOSbench.gitCheckout( "master" )
-            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" )
-        main.ONOSbench.getVersion( report=True )
-
-        cellResult = main.ONOSbench.setCell( cellName )
-        verifyResult = main.ONOSbench.verifyCell()
-        main.step( "Creating ONOS package" )
-        packageResult = main.ONOSbench.onosPackage()
-
-        main.step( "Installing ONOS package" )
-        onos1InstallResult = main.ONOSbench.onosInstall( options="-f",
-                                                           node=ONOS1Ip )
-
-        main.step( "Checking if ONOS is up yet" )
-        for i in range( 2 ):
-            onos1Isup = main.ONOSbench.isup( ONOS1Ip )
-            if onos1Isup:
-                break
-        if not onos1Isup:
-            main.log.report( "ONOS1 didn't start!" )
-
-        # TODO: if it becomes an issue, we can retry this step  a few times
-
-        cliResult = main.ONOScli1.startOnosCli( ONOS1Ip )
-
-        case1Result = ( cleanInstallResult and packageResult and
-                        cellResult and verifyResult and
-                        onos1InstallResult and
-                        onos1Isup and cliResult )
-
-        utilities.assert_equals( expect=main.TRUE, actual=case1Result,
-                                 onpass="Test startup successful",
-                                 onfail="Test startup NOT successful" )
-
-        if case1Result == main.FALSE:
-            main.cleanup()
-            main.exit()
-
-        # Starting the mininet using the old way
-        main.step( "Starting Mininet ..." )
-        netIsUp = main.Mininet1.startNet()
-        if netIsUp:
-            main.log.info("Mininet CLI is up")
-        else:
-            main.log.info("Mininet CLI is down")
-
-    def CASE2( self, main ):
-        """
-           Assign mastership to controller
-        """
-        import re
-
-        main.log.report( "Assigning switches to controller" )
-        main.case( "Assigning Controller" )
-        main.step( "Assign switches to controller" )
-
-        ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
-        ONOS1Port = main.params[ 'CTRL' ][ 'port1' ]
-
-        for i in range( 1, 14 ):
-            main.Mininet1.assignSwController(
-                sw=str( i ),
-                ip1=ONOS1Ip,
-                port1=ONOS1Port )
-
-        mastershipCheck = main.TRUE
-        for i in range( 1, 14 ):
-            response = main.Mininet1.getSwController( "s" + str( i ) )
-            try:
-                main.log.info( str( response ) )
-            except Exception:
-                main.log.info( repr( response ) )
-            if re.search( "tcp:" + ONOS1Ip, response ):
-                mastershipCheck = mastershipCheck and main.TRUE
-            else:
-                mastershipCheck = main.FALSE
-        if mastershipCheck == main.TRUE:
-            main.log.report( "Switch mastership assigned correctly" )
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=mastershipCheck,
-            onpass="Switch mastership assigned correctly",
-            onfail="Switches not assigned correctly to controllers" )
-
-    def CASE3( self, main ):
-        """
-           Install forwarding app, Pingall and unistall the app
-        """
-        import time
-
-        main.log.report( "Run Pingall" )
-        main.case( "Run Pingall" )
-
-        # install onos-app-fwd
-        main.step( "Activate reactive forwarding app" )
-        main.ONOScli1.activateApp( "org.onosproject.fwd" )
-
-        # REACTIVE FWD test
-        main.step( "Run the pingall command in Mininet" )
-        pingResult = main.FALSE
-        time1 = time.time()
-        pingResult = main.Mininet1.pingall()
-        time2 = time.time()
-        main.log.info( "Time for pingall: %2f seconds" % ( time2 - time1 ) )
-
-        # uninstall onos-app-fwd
-        main.step( "Deactivate reactive forwarding app" )
-        main.ONOScli1.deactivateApp( "org.onosproject.fwd" )
-
-        utilities.assert_equals( expect=main.TRUE, actual=pingResult,
-                                 onpass="All hosts are reachable",
-                                 onfail="Some pings failed" )
diff --git a/TestON/tests/SingleFunc/MultiFunc.topo b/TestON/tests/SingleFunc/MultiFunc.topo
deleted file mode 100755
index f8c2eab..0000000
--- a/TestON/tests/SingleFunc/MultiFunc.topo
+++ /dev/null
@@ -1,57 +0,0 @@
-<TOPOLOGY>
-    <COMPONENT>
-
-        <ONOSbench>
-            <host>10.128.10.20</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>OnosDriver</type>
-            <connect_order>1</connect_order>
-            <COMPONENTS> </COMPONENTS>
-        </ONOSbench>
-
-        <ONOScli1>
-            <host>10.128.10.21</host>
-            <user>sdn</user>
-            <password>sdn</password>
-            <type>OnosCliDriver</type>
-            <connect_order>2</connect_order>
-            <COMPONENTS> </COMPONENTS>
-        </ONOScli1>
-
-        <ONOScli2>
-            <host>10.128.10.22</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>OnosCliDriver</type>
-            <connect_order>3</connect_order>
-            <COMPONENTS> </COMPONENTS>
-        </ONOScli2>
-
-         <ONOScli3>
-            <host>10.128.10.23</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>OnosCliDriver</type>
-            <connect_order>4</connect_order>
-            <COMPONENTS> </COMPONENTS>
-        </ONOScli3>
-       
-
-        <Mininet1>
-            <host>10.128.10.11</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>MininetCliDriver</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>
-        </Mininet1>
-
-    </COMPONENT>
-</TOPOLOGY>
diff --git a/TestON/tests/SingleFunc/SingleFunc.params b/TestON/tests/SingleFunc/SingleFunc.params
deleted file mode 100755
index 58427cc..0000000
--- a/TestON/tests/SingleFunc/SingleFunc.params
+++ /dev/null
@@ -1,20 +0,0 @@
-<PARAMS>
-
-    <testcases>10,11</testcases>
-    <ENV>
-        <cellName>single_func</cellName>
-    </ENV>
-    <GIT>
-        <pull>False</pull>
-        <branch>master</branch>
-    </GIT>
-    <CTRL>
-        <ip1>10.128.10.21</ip1>
-        <port1>6633</port1>
-    </CTRL>
-    <MININET>
-        <switch>7</switch>
-        <topo>~/mininet/custom/newFuncTopo.py</topo>
-    </MININET>
-
-</PARAMS>
diff --git a/TestON/tests/SingleFunc/SingleFunc.py b/TestON/tests/SingleFunc/SingleFunc.py
deleted file mode 100644
index b971d8c..0000000
--- a/TestON/tests/SingleFunc/SingleFunc.py
+++ /dev/null
@@ -1,166 +0,0 @@
-
-# Testing the basic functionality of ONOS Next
-# For sanity and driver functionality excercises only.
-
-import time
-import json
-
-time.sleep( 1 )
-
-class SingleFunc:
-
-    def __init__( self ):
-        self.default = ''
-
-    def CASE10( self, main ):
-        import time
-        import os
-        """
-        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
-        """
-        #Local variables
-        cellName = main.params[ 'ENV' ][ 'cellName' ]
-        main.ONOS1ip = os.environ[ 'OC1' ]
-        main.ONOS1port = main.params[ 'CTRL' ][ 'port1' ]
-        main.numSwitch = int( main.params[ 'MININET' ][ 'switch' ] )
-        gitBranch = main.params[ 'GIT' ][ 'branch' ]
-        topology = main.params[ 'MININET' ][ 'topo' ]
-        PULLCODE = False
-        if main.params[ 'GIT' ][ 'pull' ] == 'True':
-            PULLCODE = True
-        main.case( "Setting up test environment" )
-
-        main.step( "Apply cell to environment" )
-        cellResult = main.ONOSbench.setCell( cellName )
-        verifyResult = main.ONOSbench.verifyCell()
-        stepResult = cellResult and verifyResult
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=stepResult,
-                                 onpass="Successfully applied cell to " + \
-                                        "environment",
-                                 onfail="Failed to apply cell to environment " )
-        """main.step( "Removing raft logs" )
-        removeRaftResult = main.ONOSbench.onosRemoveRaftLogs()
-        stepResult = removeRaftResult
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=stepResult,
-                                 onpass="Successfully removed raft logs",
-                                 onfail="Failed to remove raft logs" )
-        """
-        if PULLCODE:
-            main.step( "Git checkout and pull " + gitBranch )
-            main.ONOSbench.gitCheckout( gitBranch )
-            gitPullResult = main.ONOSbench.gitPull()
-            if gitPullResult == main.ERROR:
-                main.log.error( "Error pulling git branch" )
-            main.step( "Using mvn clean & install" )
-            cleanInstallResult = main.ONOSbench.cleanInstall()
-            stepResult = cleanInstallResult
-            utilities.assert_equals( expect=main.TRUE,
-                                     actual=stepResult,
-                                     onpass="Successfully compiled latest ONOS",
-                                     onfail="Failed to compile latest ONOS" )
-        else:
-            main.log.warn( "Did not pull new code so skipping mvn " +
-                           "clean install" )
-
-        main.step( "Creating ONOS package" )
-        packageResult = main.ONOSbench.onosPackage()
-        stepResult = packageResult
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=stepResult,
-                                 onpass="Successfully created ONOS package",
-                                 onfail="Failed to create ONOS package" )
-
-        main.step( "Uninstalling ONOS package" )
-        onosUninstallResult = main.ONOSbench.onosUninstall(
-                                                          nodeIp=main.ONOS1ip )
-        stepResult = onosUninstallResult
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=stepResult,
-                                 onpass="Successfully uninstalled ONOS package",
-                                 onfail="Failed to uninstall ONOS package" )
-        time.sleep( 5 )
-        main.step( "Installing ONOS package" )
-        onosInstallResult = main.ONOSbench.onosInstall( node=main.ONOS1ip )
-        stepResult = onosInstallResult
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=stepResult,
-                                 onpass="Successfully installed ONOS package",
-                                 onfail="Failed to install ONOS package" )
-
-        main.step( "Starting ONOS service" )
-        stopResult = main.TRUE
-        startResult = main.TRUE
-        onosIsUp = main.ONOSbench.isup()
-        if onosIsUp == main.TRUE:
-            main.log.report( "ONOS instance is up and ready" )
-        else:
-            main.log.report( "ONOS instance may not be up, stop and " +
-                             "start ONOS again " )
-            stopResult = main.ONOSbench.onosStop( main.ONOS1ip )
-            startResult = main.ONOSbench.onosStart( main.ONOS1ip )
-        stepResult = onosIsUp and stopResult and startResult
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=stepResult,
-                                 onpass="ONOS service is ready",
-                                 onfail="ONOS service did not start properly" )
-
-        main.step( "Starting Mininet Topology" )
-        topoResult = main.Mininet1.startNet( topoFile=topology )
-        stepResult = topoResult
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=stepResult,
-                                 onpass="Successfully loaded topology",
-                                 onfail="Failed to load topology" )
-        # Exit if topology did not load properly
-        if not topoResult:
-            main.cleanup()
-            main.exit()
-
-        main.step( "Start ONOS cli" )
-        cliResult =  main.ONOScli1.startOnosCli( ONOSIp=main.ONOS1ip )
-        stepResult = cliResult
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=stepResult,
-                                 onpass="Successfully start ONOS cli",
-                                 onfail="Failed to start ONOS cli" )
-
-    def CASE11( self, main ):
-        """
-        Assign mastership to controllers
-        """
-        import re
-        main.log.report( "Assigning switches to controllers" )
-        main.log.case( "Assigning swithes to controllers" )
-
-        main.step( "Assigning switches to controllers" )
-        assignResult = main.TRUE
-        for i in range( 1, ( main.numSwitch + 1 ) ):
-            main.Mininet1.assignSwController( sw=str( i ),
-                                              count=1,
-                                              ip1=main.ONOS1ip,
-                                              port1=main.ONOS1port )
-        for i in range( 1, ( main.numSwitch + 1 ) ):
-            response = main.Mininet1.getSwController( "s" + str( i ) )
-            print( "Response is " + str( response ) )
-            if re.search( "tcp:" + main.ONOS1ip, response ):
-                assignResult = assignResult and main.TRUE
-            else:
-                assignResult = main.FALSE
-        stepResult = assignResult
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=stepResult,
-                                 onpass="Successfully assigned switches" +
-                                        "to controller",
-                                 onfail="Failed to assign switches to " +
-                                        "controller" )
-
diff --git a/TestON/tests/SingleFunc/SingleFunc.topo b/TestON/tests/SingleFunc/SingleFunc.topo
deleted file mode 100755
index d92bb7a..0000000
--- a/TestON/tests/SingleFunc/SingleFunc.topo
+++ /dev/null
@@ -1,52 +0,0 @@
-<TOPOLOGY>
-    <COMPONENT>
-
-        <ONOSbench>
-            <host>10.128.10.20</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>OnosDriver</type>
-            <connect_order>1</connect_order>
-            <COMPONENTS>
-                <home>~/ONOS</home>
-            </COMPONENTS>
-        </ONOSbench>
-
-        <ONOScli1>
-            <host>10.128.10.20</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>OnosCliDriver</type>
-            <connect_order>2</connect_order>
-            <COMPONENTS> </COMPONENTS>
-        </ONOScli1>
-
-        <ONOScli2>
-            <host>10.128.10.20</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>OnosCliDriver</type>
-            <connect_order>3</connect_order>
-            <COMPONENTS> </COMPONENTS>
-        </ONOScli2>
-
-         <ONOScli3>
-            <host>10.128.10.20</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>OnosCliDriver</type>
-            <connect_order>4</connect_order>
-            <COMPONENTS> </COMPONENTS>
-        </ONOScli3>
-
-        <Mininet1>
-            <host>10.128.10.20</host>
-            <user>admin</user>
-            <password>onos_test</password>
-            <type>MininetCliDriver</type>
-            <connect_order>5</connect_order>
-            <COMPONENTS> </COMPONENTS>
-        </Mininet1>
-
-    </COMPONENT>
-</TOPOLOGY>
diff --git a/TestON/tests/SingleFunc/SingleFunc2.py b/TestON/tests/SingleFunc/SingleFunc2.py
deleted file mode 100644
index af88686..0000000
--- a/TestON/tests/SingleFunc/SingleFunc2.py
+++ /dev/null
@@ -1,661 +0,0 @@
-
-# Testing the basic functionality of ONOS Next
-# For sanity and driver functionality excercises only.
-
-import time
-# import sys
-# import os
-# import re
-import json
-
-time.sleep( 1 )
-
-class IpOptical:
-
-    def __init__( self ):
-        self.default = ''
-
-    def CASE1( self, main ):
-        import time
-        """
-        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 get version" )
-        #main.ONOSbench.gitCheckout( "master" )
-        gitPullResult = main.ONOSbench.gitPull()
-        main.log.info( "git_pull_result = " + str( 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( "Uninstalling ONOS package" )
-        ONOSip1 = main.params[ 'CTRL' ][ 'ip1' ]
-        onosUninstallResult = main.ONOSbench.onosUninstall( nodeIp = ONOSip1)
-        if onosUninstallResult:
-            main.log.report( "Uninstalling ONOS package successful" )
-        else:
-            main.log.report( "Uninstalled ONOS package unsucessful" )
-        time.sleep( 5 )
-        main.step( "Installing ONOS package" )
-        onosInstallResult = main.ONOSbench.onosInstall( node = ONOSip1 )
-        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' ] )
-        main.step( "Starting Mininet CLI..." )
-        
-        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 CASE20( self ):
-        """
-            Exit from mininet cli
-            reinstall ONOS
-        """
-        import time
-        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" )
-        step1Result = main.TRUE
-        mininetDisconnect = main.Mininet1.disconnect()
-        print "mininetDisconnect = ", mininetDisconnect
-        step1Result = mininetDisconnect
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step1Result,
-            onpass="Mininet disconnect successfully",
-            onfail="Mininet failed to disconnect")
-        """
-        main.step( "Removing raft logs before a clean installation of ONOS" )
-        step2Result = main.TRUE
-        removeRaftLogsResult = main.ONOSbench.onosRemoveRaftLogs()
-        step2Result = removeRaftLogsResult
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step2Result,
-            onpass="Raft logs removed successfully",
-            onfail="Failed to remove raft logs")
-        """
-        main.step( "Applying cell variable to environment" )
-        step3Result = main.TRUE
-        setCellResult = main.ONOSbench.setCell( cellName )
-        verifyCellResult = main.ONOSbench.verifyCell()
-        step3Result = setCellResult and verifyCellResult
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step3Result,
-            onpass="Cell applied successfully",
-            onfail="Failed to apply cell")
-
-        main.step( "Uninstalling ONOS package" )
-        step4Result = main.TRUE
-        ONOSip1 = main.params[ 'CTRL' ][ 'ip1' ]
-        onosUninstallResult = main.ONOSbench.onosUninstall( nodeIp = ONOSip1)
-        step4Result = onosUninstallResult
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step4Result,
-            onpass="Successfully uninstalled ONOS",
-            onfail="Failed to uninstall ONOS")
-
-        time.sleep( 5 )
-        main.step( "Installing ONOS package" )
-        step5Result = main.TRUE
-        onosInstallResult = main.ONOSbench.onosInstall( node = ONOSip1 )
-        step5Result = onosInstallResult
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step5Result,
-            onpass="Successfully installed ONOS",
-            onfail="Failed to install ONOS")
-
-        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" )
-        step6Result = main.TRUE
-        startResult = main.ONOSbench.onosStart( ONOS1Ip )
-        step6Result = startResult
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step6Result,
-            onpass="Successfully started ONOS",
-            onfail="Failed to start ONOS")
-
-        main.step( "Starting ONOS cli" )
-        step7Result = main.TRUE
-        cliResult = main.ONOS2.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
-        step7Result = cliResult
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step7Result,
-            onpass="Successfully started ONOS cli",
-            onfail="Failed to start ONOS cli")
-
-        case20Result = step1Result and step3Result and\
-                       step4Result and step5Result and step6Result and\
-                       step7Result
-        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:
-            sudo -E python ~/onos/tools/test/topos/opticalTest.py -OC1
-            which spawns packet optical topology 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
-        """
-        import time
-        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( "Activate optical app" )
-        step1Result = main.TRUE
-        activateOpticalResult = main.ONOS2.activateApp( "org.onosproject.optical" )
-        step1Result = activateOpticalResult
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step1Result,
-            onpass="Successfully activated optical app",
-            onfail="Failed to activate optical app")
-
-        appCheck = main.ONOS2.appToIDCheck()
-        if appCheck != main.TRUE:
-            main.log.warn( main.ONOS2.apps() )
-            main.log.warn( main.ONOS2.appIDs() )
-
-        main.step( "Starting mininet and LINC-OE" )
-        step2Result = main.TRUE
-        time.sleep( 10 )
-        opticalMnScript = main.LincOE2.runOpticalMnScript(ctrllerIP = main.params[ 'CTRL' ][ 'ip1' ])
-        step2Result = opticalMnScript
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step2Result,
-            onpass="Started the topology successfully ",
-            onfail="Failed to start the topology")
-
-        case21Result = step1Result and step2Result
-        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, 10 optical switches(ROADM's) and
-            6 packet layer mininet switches each with one host.
-            Therefore, the roadmCount variable = 10,
-            packetLayerSWCount variable = 6, hostCount=6 and
-            links=42.
-            All this is hardcoded in the testcase. If the topology changes,
-            these hardcoded values need to be changed
-        """
-        import time
-        main.log.report(
-            "This testcase compares the optical+packet topology against what" +
-            " is expected" )
-        main.case( "Topology comparision" )
-
-        main.step( "Starts new ONOS cli" )
-        step1Result = main.TRUE
-        cliResult = main.ONOS3.startOnosCli( ONOSIp=main.params[ 'CTRL' ]\
-                                                               [ 'ip1' ] )
-        step1Result = cliResult
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step1Result,
-            onpass="Successfully starts a new cli",
-            onfail="Failed to start new cli" )
-
-        main.step( "Compare topology" )
-        step2Result = main.TRUE
-        devicesResult = main.ONOS3.devices( jsonFormat=False )
-        print "devices_result :\n", devicesResult
-        devicesLinewise = devicesResult.split( "\n" )
-        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 == 10:
-            print "Number of Optical Switches = %d and is" % roadmCount +\
-                  " correctly detected"
-            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 == 6:
-            print "Number of Packet layer or mininet Switches = %d "\
-                    % packetLayerSWCount + "and is correctly detected"
-            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"\
-                    % packetLayerSWCount + " is wrong"
-            main.log.info(
-                "Number of Packet layer or mininet Switches = " +
-                str( packetLayerSWCount ) +
-                " and is wrong" )
-            packetSWResult = main.FALSE
-        # sleeps for sometime so the state of the switches will be active
-        time.sleep( 30 )
-        print "_________________________________"
-        linksResult = main.ONOS3.links( jsonFormat=False )
-        print "links_result = ", linksResult
-        print "_________________________________"
-        linkActiveCount = linksResult.count("state=ACTIVE")
-        main.log.info( "linkActiveCount = " + str( linkActiveCount ))
-        if linkActiveCount == 42:
-            linkActiveResult = main.TRUE
-            main.log.info(
-                "Number of links in ACTIVE state are correct")
-        else:
-            linkActiveResult = main.FALSE
-            main.log.info(
-                "Number of links in ACTIVE state are wrong")
-        step2Result = opticalSWResult and packetSWResult and \
-                        linkActiveResult
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step2Result,
-            onpass="Successfully loaded packet optical topology",
-            onfail="Failed to load packet optical topology" )
-
-        case22Result = step1Result and step2Result
-
-        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( "Install point intents between 2 packet layer device and " +
-                   "ping the hosts" )
-
-        main.step( "Adding point intents" )
-        step1Result = main.TRUE
-        intentsId = []
-        pIntent1 = main.ONOS3.addPointIntent(
-            "of:0000ffffffff0001/1",
-            "of:0000ffffffff0005/1" )
-        pIntent2 = main.ONOS3.addPointIntent(
-            "of:0000ffffffff0005/1",
-            "of:0000ffffffff0001/1" )
-        intentsId.append( pIntent1 )
-        intentsId.append( pIntent2 )
-        main.log.info( "Checking intents state")
-        checkStateResult = main.ONOS3.checkIntentState( intentsId = intentsId )
-        time.sleep( 30 )
-        main.log.info( "Checking flows state")
-        checkFlowResult = main.ONOS3.checkFlowsState()
-        # Sleep for 30 seconds to provide time for the intent state to change
-        time.sleep( 30 )
-        main.log.info( "Checking intents state one more time")
-        checkStateResult = main.ONOS3.checkIntentState( intentsId = intentsId )
-        step1Result = checkStateResult and checkFlowResult
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step1Result,
-            onpass="Successfully added point intents",
-            onfail="Failed to add point intents")
-
-        main.step( "Ping h1 and h5" )
-        step2Result = main.TRUE
-        main.log.info( "\n\nh1 is Pinging h5" )
-        pingResult = main.LincOE2.pingHostOptical( src="h1", target="h5" )
-        step2Result = pingResult
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step2Result,
-            onpass="Successfully pinged h1 and h5",
-            onfail="Failed to ping between h1 and h5")
-
-        case23Result = step1Result and step2Result
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=case23Result,
-            onpass="Point intents are installed properly",
-            onfail="Failed to install point intents" )
-
-    def CASE24( self, main ):
-        import time
-        import json
-        """
-            LINC uses its own switch IDs. You can use the following
-            command on the LINC console to find the mapping between 
-            DPIDs and LINC IDs.
-            rp(application:get_all_key(linc)).
-            
-            Test Rerouting of Packet Optical by bringing a port down
-            ( port 20 ) of a switch( switchID=1, or LincOE switchID =9 ), 
-            so that link
-            ( between switch1 port20 - switch5 port50 ) 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( "Attach to the Linc-OE session" )
-        step1Result = main.TRUE
-        attachConsole = main.LincOE1.attachLincOESession()
-        step1Result = attachConsole
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step1Result,
-            onpass="Successfully attached Linc-OE session",
-            onfail="Failed to attached Linc-OE session")
-
-        main.step( "Bring a port down and verify the link state" )
-        step2Result = main.TRUE
-        main.LincOE1.portDown( swId="9", ptId="20" )
-        linksNonjson = main.ONOS3.links( jsonFormat=False )
-        main.log.info( "links = " + linksNonjson )
-        linkInactiveCount = linksNonjson.count( "state=INACTIVE" )
-        main.log.info( "linkInactiveCount = " + str( linkInactiveCount ))
-        if linkInactiveCount == 2:
-            main.log.info(
-                "Number of links in INACTIVE state are correct")
-        else:
-            main.log.info(
-                "Number of links in INACTIVE state are wrong")
-        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' ] == "20":
-                if item[ 'dst' ][ 'device' ] == "of:0000ffffffffff05" and item[
-                        'dst' ][ 'port' ] == "50":
-                    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
-        time.sleep( 10 )
-        checkFlowsState = main.ONOS3.checkFlowsState()
-        step2Result = linksStateResult
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step2Result,
-            onpass="Successfuly brought down a link",
-            onfail="Failed to bring down a link")
-
-        main.step( "Verify Rerouting by a ping test" )
-        step3Result = main.TRUE
-        main.log.info( "\n\nh1 is Pinging h5" )
-        pingResult = main.LincOE2.pingHostOptical( src="h1", target="h5" )
-        step3Result = pingResult
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step3Result,
-            onpass="Successfully pinged h1 and h5",
-            onfail="Failed to ping between h1 and h5")
-
-        main.step( "Bring the downed port up and verify the link state" )
-        step4Result = main.TRUE
-        main.LincOE1.portUp( swId="9", ptId="20" )
-        linksNonjson = main.ONOS3.links( jsonFormat=False )
-        main.log.info( "links = " + linksNonjson )
-        linkInactiveCount = linksNonjson.count( "state=INACTIVE" )
-        main.log.info( "linkInactiveCount = " + str( linkInactiveCount ))
-        if linkInactiveCount == 0:
-            main.log.info(
-                "Number of links in INACTIVE state are correct")
-        else:
-            main.log.info(
-                "Number of links in INACTIVE state are wrong")
-            step4Result = main.FALSE
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step4Result,
-            onpass="Successfully brought the port up",
-            onfail="Failed to bring the port up")
-
-        case24Result = step1Result and step2Result and step3Result \
-                       and step4Result
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=case24Result,
-                                 onpass="Packet optical rerouting successful",
-                                 onfail="Packet optical rerouting failed" )
-
-    def CASE10( self ):
-        main.log.report(
-            "This testcase uninstalls the reactive forwarding app" )
-        main.log.report( "__________________________________" )
-        main.case( "Uninstalling reactive forwarding app" )
-        main.step( "Uninstalling reactive forwarding app" )
-        step1Result = main.TRUE
-        # Unistall onos-app-fwd app to disable reactive forwarding
-        main.log.info( "deactivate reactive forwarding app" )
-        appUninstallResult = main.ONOS2.deactivateApp( "org.onosproject.fwd" )
-        appCheck = main.ONOS2.appToIDCheck()
-        if appCheck != main.TRUE:
-            main.log.warn( main.ONOS2.apps() )
-            main.log.warn( main.ONOS2.appIDs() )
-        step1Result = appUninstallResult
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step1Result,
-            onpass="Successfully deactivate reactive forwarding app",
-            onfail="Failed to deactivate reactive forwarding app")
-        # 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 = step1Result
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=case10Result,
-            onpass="Reactive forwarding app uninstallation successful",
-            onfail="Reactive forwarding app uninstallation failed" )
-
-    def CASE25( self ):
-        """
-            Add host intents between 2 packet layer host
-        """
-        import time
-        import json
-        main.log.report( "Adding host intents between 2 optical layer host" )
-        main.case( "Test add host intents between optical layer host" )
-
-        main.step( "Discover host using arping" )
-        step1Result = main.TRUE
-        main.hostMACs = []
-        main.hostId = []
-        #Listing host MAC addresses
-        for i in range( 1 , 7 ):
-            main.hostMACs.append( "00:00:00:00:00:" +
-                                str( hex( i )[ 2: ] ).zfill( 2 ).upper() )
-        for macs in main.hostMACs:
-            main.hostId.append( macs + "/-1" )
-        host1 = main.hostId[ 0 ]
-        host2 = main.hostId[ 1 ]
-        # Use arping to discover the hosts
-        main.LincOE2.arping( host = "h1" )
-        main.LincOE2.arping( host = "h2" )
-        time.sleep( 5 )
-        hostsDict = main.ONOS3.hosts()
-        if not len( hostsDict ):
-            step1Result = main.FALSE
-        # Adding host intent
-        utilities.assert_equals(
-            expect=main.TRUE,
-            actual=step1Result,
-            onpass="Hosts discovered",
-            onfail="Failed to discover hosts")
-
-        main.step( "Adding host intents to h1 and h2" )
-        step2Result = main.TRUE
-        intentsId = []
-        intent1 = main.ONOS3.addHostIntent( hostIdOne = host1,
-                                            hostIdTwo = host2 )
-        intentsId.append( intent1 )
-        time.sleep( 5 )
-        intent2 = main.ONOS3.addHostIntent( hostIdOne = host2,
-                                            hostIdTwo = host1 )
-        intentsId.append( intent2 )
-        # Checking intents state before pinging
-        main.log.info( "Checking intents state" )
-        time.sleep( 15 )
-        intentResult = main.ONOS3.checkIntentState( intentsId = intentsId )
-        #check intent state again if intents are not in installed state
-        if not intentResult:
-           intentResult = main.ONOS3.checkIntentState( intentsId = intentsId )
-        step2Result = intentResult
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=step2Result,
-                                 onpass="All intents are in INSTALLED state ",
-                                 onfail="Some of the intents are not in " +
-                                        "INSTALLED state " )
-
-        # pinging h1 to h2 and then ping h2 to h1
-        main.step( "Pinging h1 and h2" )
-        step3Result = main.TRUE
-        pingResult = main.TRUE
-        pingResult = main.LincOE2.pingHostOptical( src="h1", target="h2" )
-        pingResult = pingResult and main.LincOE2.pingHostOptical( src="h2",
-                                                                  target="h1" )
-        step3Result = pingResult
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=step3Result,
-                                 onpass="Pinged successfully between h1 and h2",
-                                 onfail="Pinged failed between h1 and h2" )
-        # Removed all added host intents
-        main.step( "Removing host intents" )
-        step4Result = main.TRUE
-        removeResult = main.TRUE
-        # Check remaining intents
-        intentsJson = json.loads( main.ONOS3.intents() )
-        main.ONOS3.removeIntent( intentId=intent1, purge=True )
-        main.ONOS3.removeIntent( intentId=intent2, purge=True )
-        for intents in intentsJson:
-            main.ONOS3.removeIntent( intentId=intents.get( 'id' ),
-                                     app='org.onosproject.optical',
-                                     purge=True )
-        print json.loads( main.ONOS3.intents() )
-        if len( json.loads( main.ONOS3.intents() ) ):
-            removeResult = main.FALSE
-        step4Result = removeResult
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=step4Result,
-                                 onpass="Successfully removed host intents",
-                                 onfail="Failed to remove host intents" )
-        case25Result = step1Result and step2Result and step3Result and \
-                       step4Result
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=case25Result,
-                                 onpass="Add host intent successful",
-                                 onfail="Add host intent failed" )
diff --git a/TestON/tests/SingleFunc/__init__.py b/TestON/tests/SingleFunc/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/TestON/tests/SingleFunc/__init__.py
+++ /dev/null
diff --git a/TestON/tests/SingleFunc/lala.py b/TestON/tests/SingleFunc/lala.py
deleted file mode 100644
index 372f8c7..0000000
--- a/TestON/tests/SingleFunc/lala.py
+++ /dev/null
@@ -1,8 +0,0 @@
-        main.log.report()
-        main.log.case()
-        main.step()
-
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=stepResult,
-                                 onpass="",
-                                 onfail="" )