diff --git a/TestON/drivers/common/cli/emulator/mininethostdriver.py b/TestON/drivers/common/cli/emulator/mininethostdriver.py
new file mode 100644
index 0000000..408f918
--- /dev/null
+++ b/TestON/drivers/common/cli/emulator/mininethostdriver.py
@@ -0,0 +1,198 @@
+#!/usr/bin/env python
+"""
+Copyright 2018 Open Networking Foundation (ONF)
+
+Please refer questions to either the onos test mailing list at <onos-test@onosproject.org>,
+the System Testing Plans and Results wiki page at <https://wiki.onosproject.org/x/voMg>,
+or the System Testing Guide page at <https://wiki.onosproject.org/x/WYQg>
+
+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/>.
+"""
+
+import pexpect
+import re
+import sys
+import types
+import os
+import time
+from math import pow
+from drivers.common.cli.emulatordriver import Emulator
+from core.graph import Graph
+
+
+class MininetHostDriver( Emulator ):
+    """
+    This class is created as a standalone Mininet host driver. It could
+    be used as driver for a mock physical host for proof-of-concept
+    testing in physical environment.
+    """
+    def __init__( self ):
+        super( MininetHostDriver, self ).__init__()
+        self.handle = self
+        self.name = None
+        self.shortName = None
+        self.home = None
+        self.hostPrompt = "~#"
+
+    def connect( self, **connectargs ):
+        """
+        Creates ssh handle for the Mininet host.
+        NOTE:
+        The ip_address would come from the topo file using the host tag, the
+        value can be an environment variable as well as a "localhost" to get
+        the ip address needed to ssh to the "bench"
+        """
+        try:
+            for key in connectargs:
+                vars( self )[ key ] = connectargs[ key ]
+            self.name = self.options[ 'name' ]
+            self.shortName = self.options[ 'shortName' ]
+
+            try:
+                if os.getenv( str( self.ip_address ) ) is not None:
+                    self.ip_address = os.getenv( str( self.ip_address ) )
+                else:
+                    main.log.info( self.name +
+                                   ": Trying to connect to " +
+                                   self.ip_address )
+            except KeyError:
+                main.log.info( "Invalid host name," +
+                               " connecting to local host instead" )
+                self.ip_address = 'localhost'
+            except Exception as inst:
+                main.log.error( "Uncaught exception: " + str( inst ) )
+
+            self.handle = super(
+                MininetHostDriver,
+                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 " +
+                               self.user_name +
+                               "@" +
+                               self.ip_address )
+                self.handle.sendline( "~/mininet/util/m " + self.shortName )
+                self.handle.sendline( "cd" )
+                self.handle.expect( self.hostPrompt )
+                self.handle.sendline( "" )
+                self.handle.expect( self.hostPrompt )
+                return main.TRUE
+            else:
+                main.log.error( "Connection failed to " +
+                                self.user_name +
+                                "@" +
+                                self.ip_address )
+                return main.FALSE
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
+            main.cleanAndExit()
+        except Exception:
+            main.log.exception( self.name + ": Uncaught exception!" )
+            main.cleanAndExit()
+
+    def disconnect( self, **connectargs ):
+        """
+        Called when test is complete to disconnect the handle.
+        """
+        try:
+            self.handle.sendline( '' )
+            i = self.handle.expect( [ self.hostPrompt, pexpect.EOF, pexpect.TIMEOUT ],
+                                    timeout=2 )
+            if i == 0:
+                return main.TRUE
+            elif i == 1:
+                return main.TRUE
+            else:
+                main.log.error( "Connection failed to the host" )
+            return main.ERROR
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
+            main.cleanAndExit()
+        except Exception:
+            main.log.exception( self.name + ": Uncaught exception!" )
+            main.cleanAndExit()
+
+    def ping( self, dst, ipv6=False, wait=3 ):
+        """
+        Description:
+            Ping from this host to another
+        Required:
+            dst: IP address of destination host
+        Optional:
+            ipv6: will use ping6 command if True; otherwise use ping command
+            wait: timeout for ping command
+        """
+        try:
+            command = "ping6" if ipv6 else "ping"
+            command += " -c 1 -i 1 -W " + str( wait ) + " " + str( dst )
+            main.log.info( self.name + ": Sending: " + command )
+            self.handle.sendline( command )
+            i = self.handle.expect( [ self.hostPrompt, pexpect.TIMEOUT ],
+                                    timeout=wait + 1 )
+            if i == 1:
+                main.log.error(
+                    self.name +
+                    ": timeout when waiting for response" )
+                main.log.error( "response: " + str( self.handle.before ) )
+            self.handle.sendline( "" )
+            self.handle.expect( self.hostPrompt )
+            response = self.handle.before
+            if re.search( ',\s0\%\spacket\sloss', response ):
+                main.log.info( self.name + ": no packets lost, host is reachable" )
+                return main.TRUE
+            else:
+                main.log.warn(
+                    self.name +
+                    ": PACKET LOST, HOST IS NOT REACHABLE" )
+                return main.FALSE
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
+            main.cleanAndExit()
+        except Exception:
+            main.log.exception( self.name + ": Uncaught exception!" )
+            main.cleanAndExit()
+
+    def ifconfig( self, wait=3 ):
+        """
+        Run ifconfig command on host and return output
+        """
+        try:
+            command = "ifconfig"
+            main.log.info( self.name + ": Sending: " + command )
+            self.handle.sendline( command )
+            i = self.handle.expect( [ self.hostPrompt, pexpect.TIMEOUT ],
+                                    timeout=wait + 1 )
+            if i == 1:
+                main.log.error(
+                    self.name +
+                    ": timeout when waiting for response" )
+                main.log.error( "response: " + str( self.handle.before ) )
+            self.handle.sendline( "" )
+            self.handle.expect( self.hostPrompt )
+            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.cleanAndExit()
+        except Exception:
+            main.log.exception( self.name + ": Uncaught exception!" )
+            main.cleanAndExit()
diff --git a/TestON/drivers/common/cli/emulator/mininethostscapyclidriver.py b/TestON/drivers/common/cli/emulator/mininethostscapyclidriver.py
new file mode 100644
index 0000000..b2ebd74
--- /dev/null
+++ b/TestON/drivers/common/cli/emulator/mininethostscapyclidriver.py
@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+"""
+2015-2016
+Copyright 2016 Open Networking Foundation (ONF)
+
+Please refer questions to either the onos test mailing list at <onos-test@onosproject.org>,
+the System Testing Plans and Results wiki page at <https://wiki.onosproject.org/x/voMg>,
+or the System Testing Guide page at <https://wiki.onosproject.org/x/WYQg>
+
+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/>.
+
+"""
+import pexpect
+import re
+import sys
+import types
+import os
+from drivers.common.cli.emulator.scapyclidriver import ScapyCliDriver
+
+
+class MininetHostScapyCliDriver( ScapyCliDriver ):
+
+    """
+    This class is created as a standalone Mininet host scapy driver. It
+    could be used as driver for a mock physical host for proof-of-concept
+    testing in physical environment.
+    """
+    def __init__( self ):
+        super( MininetHostScapyCliDriver, self ).__init__()
+        self.handle = self
+        self.name = None
+        self.home = None
+        self.wrapped = sys.modules[ __name__ ]
+        self.flag = 0
+        # TODO: Refactor driver to use these everywhere
+        self.hostPrompt = "~#"
+        self.scapyPrompt = ">>>"
+
+    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.home = self.options[ 'home' ] if 'home' in self.options.keys() else "~/"
+            self.name = self.options[ 'name' ]
+            self.ifaceName = self.options[ 'ifaceName' ] if 'ifaceName' in self.options.keys() else self.name + "-eth0"
+
+            try:
+                if os.getenv( str( self.ip_address ) ) is not None:
+                    self.ip_address = os.getenv( str( self.ip_address ) )
+                else:
+                    main.log.info( self.name +
+                                   ": Trying to connect to " +
+                                   self.ip_address )
+
+            except KeyError:
+                main.log.info( "Invalid host name," +
+                               " connecting to local host instead" )
+                self.ip_address = 'localhost'
+            except Exception as inst:
+                main.log.error( "Uncaught exception: " + str( inst ) )
+
+            self.handle = super(
+                ScapyCliDriver,
+                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 )
+                self.handle.sendline( "~/mininet/util/m " + self.name )
+                self.handle.sendline( "cd" )
+                self.handle.expect( self.hostPrompt )
+                self.handle.sendline( "" )
+                self.handle.expect( self.hostPrompt )
+                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 Host" )
+                return main.FALSE
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
+            main.cleanAndExit()
+        except Exception:
+            main.log.exception( self.name + ": Uncaught exception!" )
+            main.cleanAndExit()
+
+    def disconnect( self ):
+        """
+        Called when test is complete to disconnect the handle.
+        """
+        try:
+            self.handle.sendline( '' )
+            i = self.handle.expect( [ self.hostPrompt, pexpect.EOF, pexpect.TIMEOUT ],
+                                    timeout=2 )
+            if i == 0:
+                return main.TRUE
+            elif i == 1:
+                return main.TRUE
+            else:
+                main.log.error( "Connection failed to the host" )
+            return main.ERROR
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
+            main.cleanAndExit()
+        except Exception:
+            main.log.exception( self.name + ": Uncaught exception!" )
+            main.cleanAndExit()
+
+if __name__ != "__main__":
+    sys.modules[ __name__ ] = MininetHostScapyCliDriver()
diff --git a/TestON/drivers/common/cli/emulator/mininetswitchdriver.py b/TestON/drivers/common/cli/emulator/mininetswitchdriver.py
new file mode 100644
index 0000000..cce0c1e
--- /dev/null
+++ b/TestON/drivers/common/cli/emulator/mininetswitchdriver.py
@@ -0,0 +1,221 @@
+#!/usr/bin/env python
+"""
+Copyright 2018 Open Networking Foundation (ONF)
+
+Please refer questions to either the onos test mailing list at <onos-test@onosproject.org>,
+the System Testing Plans and Results wiki page at <https://wiki.onosproject.org/x/voMg>,
+or the System Testing Guide page at <https://wiki.onosproject.org/x/WYQg>
+
+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/>.
+"""
+
+import pexpect
+import re
+import sys
+import types
+import os
+import time
+from math import pow
+from drivers.common.cli.emulatordriver import Emulator
+from core.graph import Graph
+
+
+class MininetSwitchDriver( Emulator ):
+    """
+    This class is created as a standalone switch driver. Hoever actually the
+    switch is an ovs-switch created by Mininet. It could be used as driver
+    for a mock physical switch for proof-of-concept testing in physical
+    environment.
+    """
+    def __init__( self ):
+        super( MininetSwitchDriver, self ).__init__()
+        self.handle = self
+        self.name = None
+        self.shortName = None
+        self.home = None
+
+    def connect( self, **connectargs ):
+        """
+        Creates ssh handle for the Mininet switch.
+        NOTE:
+        The ip_address would come from the topo file using the host tag, the
+        value can be an environment variable as well as a "localhost" to get
+        the ip address needed to ssh to the "bench"
+        """
+        try:
+            for key in connectargs:
+                vars( self )[ key ] = connectargs[ key ]
+            self.home = "~/mininet"
+            self.name = self.options[ 'name' ]
+            self.shortName = self.options[ 'shortName' ]
+            for key in self.options:
+                if key == "home":
+                    self.home = self.options[ 'home' ]
+                    break
+            if self.home is None or self.home == "":
+                self.home = "~/mininet"
+
+            try:
+                if os.getenv( str( self.ip_address ) ) is not None:
+                    self.ip_address = os.getenv( str( self.ip_address ) )
+                else:
+                    main.log.info( self.name +
+                                   ": Trying to connect to " +
+                                   self.ip_address )
+
+            except KeyError:
+                main.log.info( "Invalid host name," +
+                               " connecting to local host instead" )
+                self.ip_address = 'localhost'
+            except Exception as inst:
+                main.log.error( "Uncaught exception: " + str( inst ) )
+
+            self.handle = super(
+                MininetSwitchDriver,
+                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.cleanAndExit()
+        except Exception:
+            main.log.exception( self.name + ": Uncaught exception!" )
+            main.cleanAndExit()
+
+    def disconnect( self ):
+        """
+        Called when test is complete to disconnect the handle.
+        """
+        try:
+            self.handle.sendline( '' )
+            i = self.handle.expect( [ self.prompt, pexpect.EOF, pexpect.TIMEOUT ],
+                                    timeout=2 )
+            if i == 0:
+                return main.TRUE
+            elif i == 1:
+                return main.TRUE
+            else:
+                main.log.error( "Connection failed to the host" )
+            return main.ERROR
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
+            main.cleanAndExit()
+        except Exception:
+            main.log.exception( self.name + ": Uncaught exception!" )
+            main.cleanAndExit()
+
+    def assignSwController( self, ip, port="6653", ptcp="" ):
+        """
+        Description:
+            Assign the Mininet switch to the controllers
+        Required:
+            ip - Ip addresses of controllers. This can be a list or a string.
+        Optional:
+            port - ONOS use port 6653, if no list of ports is passed, then
+                   the all the controller will use 6653 as their port number
+            ptcp - ptcp number. This needs to be a string.
+        Return:
+            Returns main.TRUE if the switch is correctly assigned to controllers,
+            otherwise it will return main.FALSE or an appropriate exception(s)
+        """
+        assignResult = main.TRUE
+        # Initial ovs command
+        commandList = []
+        command = "sudo ovs-vsctl set-controller "
+        onosIp = ""
+        try:
+            if isinstance( ip, types.StringType ):
+                onosIp = "tcp:" + str( ip ) + ":"
+                if isinstance( port, types.StringType ) or \
+                   isinstance( port, types.IntType ):
+                    onosIp += str( port )
+                elif isinstance( port, types.ListType ):
+                    main.log.error( self.name + ": Only one controller " +
+                                    "assigned and a list of ports has" +
+                                    " been passed" )
+                    return main.FALSE
+                else:
+                    main.log.error( self.name + ": Invalid controller port " +
+                                    "number. Please specify correct " +
+                                    "controller port" )
+                    return main.FALSE
+            elif isinstance( ip, types.ListType ):
+                if isinstance( port, types.StringType ) or \
+                   isinstance( port, types.IntType ):
+                    for ipAddress in ip:
+                        onosIp += "tcp:" + str( ipAddress ) + ":" + \
+                                  str( port ) + " "
+                elif isinstance( port, types.ListType ):
+                    if ( len( ip ) != len( port ) ):
+                        main.log.error( self.name + ": Port list = " +
+                                        str( len( port ) ) +
+                                        "should be the same as controller" +
+                                        " ip list = " + str( len( ip ) ) )
+                        return main.FALSE
+                    else:
+                        onosIp = ""
+                        for ipAddress, portNum in zip( ip, port ):
+                            onosIp += "tcp:" + str( ipAddress ) + ":" + \
+                                      str( portNum ) + " "
+                else:
+                    main.log.error( self.name + ": Invalid controller port " +
+                                    "number. Please specify correct " +
+                                    "controller port" )
+                    return main.FALSE
+            else:
+                main.log.error( self.name + ": Invalid ip address" )
+                return main.FALSE
+            command += self.shortName + " "
+            if ptcp:
+                if isinstance( ptcp, types.StringType ):
+                    command += "ptcp:" + str( ptcp ) + " "
+                elif isinstance( ptcp, types.ListType ):
+                    main.log.error( self.name + ": Only one switch is " +
+                                    "being set and multiple PTCP is " +
+                                    "being passed " )
+                    return main.FALSE
+                else:
+                    main.log.error( self.name + ": Invalid PTCP" )
+                    return main.FALSE
+            command += onosIp
+            self.execute( cmd=command, prompt=self.prompt, timeout=5 )
+            return main.TRUE
+        except pexpect.TIMEOUT:
+            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.cleanAndExit()
+        except Exception:
+            main.log.exception( self.name + ": Uncaught exception!" )
+            main.cleanAndExit()
diff --git a/TestON/drivers/common/cli/networkdriver.py b/TestON/drivers/common/cli/networkdriver.py
new file mode 100755
index 0000000..d1a7faf
--- /dev/null
+++ b/TestON/drivers/common/cli/networkdriver.py
@@ -0,0 +1,363 @@
+#!/usr/bin/env python
+"""
+Copyright 2018 Open Networking Foundation (ONF)
+
+Please refer questions to either the onos test mailing list at <onos-test@onosproject.org>,
+the System Testing Plans and Results wiki page at <https://wiki.onosproject.org/x/voMg>,
+or the System Testing Guide page at <https://wiki.onosproject.org/x/WYQg>
+
+    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/>.
+
+
+This driver is used to interact with a physical network that SDN controller is controlling.
+
+Please refer questions to either the onos test mailing list at <onos-test@onosproject.org>,
+the System Testing Plans and Results wiki page at <https://wiki.onosproject.org/x/voMg>,
+or the System Testing Guide page at <https://wiki.onosproject.org/x/WYQg>
+
+"""
+import pexpect
+import os
+import types
+from drivers.common.clidriver import CLI
+
+class NetworkDriver( CLI ):
+
+    def __init__( self ):
+        """
+        switches: a dictionary that maps switch names to components
+        hosts: a dictionary that maps host names to components
+        """
+        self.name = None
+        self.home = None
+        self.handle = None
+        self.switches = {}
+        self.hosts = {}
+        super( NetworkDriver, self ).__init__()
+
+    def checkOptions( self, var, defaultVar ):
+        if var is None or var == "":
+            return defaultVar
+        return var
+
+    def connect( self, **connectargs ):
+        """
+        Creates ssh handle for the SDN network "bench".
+        NOTE:
+        The ip_address would come from the topo file using the host tag, the
+        value can be an environment variable as well as a "localhost" to get
+        the ip address needed to ssh to the "bench"
+        """
+        try:
+            for key in connectargs:
+                vars( self )[ key ] = connectargs[ key ]
+            self.name = self.options[ 'name' ]
+            try:
+                if os.getenv( str( self.ip_address ) ) is not None:
+                    self.ip_address = os.getenv( str( self.ip_address ) )
+                else:
+                    main.log.info( self.name +
+                                   ": Trying to connect to " +
+                                   self.ip_address )
+            except KeyError:
+                main.log.info( "Invalid host name," +
+                               " connecting to local host instead" )
+                self.ip_address = 'localhost'
+            except Exception as inst:
+                main.log.error( "Uncaught exception: " + str( inst ) )
+
+            self.handle = super( NetworkDriver, self ).connect(
+                user_name=self.user_name,
+                ip_address=self.ip_address,
+                port=self.port,
+                pwd=self.pwd )
+
+            if self.handle:
+                main.log.info( "Connected to network bench node" )
+                return self.handle
+            else:
+                main.log.info( "Failed to create handle" )
+                return main.FALSE
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
+            main.cleanAndExit()
+        except Exception:
+            main.log.exception( self.name + ": Uncaught exception!" )
+            main.cleanAndExit()
+
+    def disconnect( self ):
+        """
+        Called when test is complete to disconnect the handle.
+        """
+        response = main.TRUE
+        try:
+            if self.handle:
+                self.handle.sendline( "exit" )
+                self.handle.expect( "closed" )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
+        except Exception:
+            main.log.exception( self.name + ": Connection failed to the host" )
+            response = main.FALSE
+        return response
+
+    def connectToNet( self ):
+        """
+        Connect to an existing physical network by getting information
+        of all switch and host components created
+        """
+        try:
+            for key, value in main.componentDictionary.items():
+                if hasattr( main, key ):
+                    if value[ 'type' ] in [ 'MininetSwitchDriver' ]:
+                        self.switches[ key ] = getattr( main, key )
+                    elif value[ 'type' ] in [ 'MininetHostDriver' ]:
+                        self.hosts[ key ] = getattr( main, key )
+            return main.TRUE
+        except Exception:
+            main.log.error( self.name + ": failed to connect to network" )
+            return main.FALSE
+
+    def getHosts( self, verbose=False, updateTimeout=1000 ):
+        """
+        Return a dictionary which maps short names to host data
+        """
+        hosts = {}
+        try:
+            for hostComponent in self.hosts.values():
+                #TODO: return more host data
+                hosts[ hostComponent.options[ 'shortName' ] ] = {}
+        except Exception:
+            main.log.error( self.name + ": host component not as expected" )
+        return hosts
+
+    def getMacAddress( self, host ):
+        """
+        Return MAC address of a host
+        """
+        import re
+        try:
+            hostComponent = self.getHostComponentByShortName( host )
+            response = hostComponent.ifconfig()
+            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
+        except Exception:
+            main.log.error( self.name + ": failed to get host MAC address" )
+
+    def getSwitchComponentByShortName( self, shortName ):
+        """
+        Get switch component by its short name i.e. "s1"
+        """
+        for switchComponent in self.switches.values():
+            if switchComponent.options[ 'shortName' ] == shortName:
+                return switchComponent
+        main.log.warn( self.name + ": failed to find switch component by name " + shortName )
+        return None
+
+    def getHostComponentByShortName( self, shortName ):
+        """
+        Get host component by its short name i.e. "h1"
+        """
+        for hostComponent in self.hosts.values():
+            if hostComponent.options[ 'shortName' ] == shortName:
+                return hostComponent
+        main.log.warn( self.name + ": failed to find host component by name " + shortName )
+        return None
+
+    def assignSwController( self, sw, ip, port="6653", ptcp="" ):
+        """
+        Description:
+            Assign switches to the controllers
+        Required:
+            sw - Short name of the switch specified in the .topo file, e.g. "s1".
+            It can also be a list of switch names.
+            ip - Ip addresses of controllers. This can be a list or a string.
+        Optional:
+            port - ONOS use port 6653, if no list of ports is passed, then
+                   the all the controller will use 6653 as their port number
+            ptcp - ptcp number, This can be a string or a list that has
+                   the same length as switch. This is optional and not required
+                   when using ovs switches.
+        NOTE: If switches and ptcp are given in a list type they should have the
+              same length and should be in the same order, Eg. sw=[ 's1' ... n ]
+              ptcp=[ '6637' ... n ], s1 has ptcp number 6637 and so on.
+
+        Return:
+            Returns main.TRUE if switches are correctly assigned to controllers,
+            otherwise it will return main.FALSE or an appropriate exception(s)
+        """
+        switchList = []
+        ptcpList = None
+        try:
+            if isinstance( sw, types.StringType ):
+                switchList.append( sw )
+                if ptcp:
+                    if isinstance( ptcp, types.StringType ):
+                        ptcpList = [ ptcp ]
+                    elif isinstance( ptcp, types.ListType ):
+                        main.log.error( self.name + ": Only one switch is " +
+                                        "being set and multiple PTCP is " +
+                                        "being passed " )
+                        return main.FALSE
+                    else:
+                        main.log.error( self.name + ": Invalid PTCP" )
+                        return main.FALSE
+
+            elif isinstance( sw, types.ListType ):
+                switchList = sw
+                if ptcp:
+                    if isinstance( ptcp, types.ListType ):
+                        if len( ptcp ) != len( sw ):
+                            main.log.error( self.name + ": PTCP length = " +
+                                            str( len( ptcp ) ) +
+                                            " is not the same as switch" +
+                                            " length = " +
+                                            str( len( sw ) ) )
+                            return main.FALSE
+                        else:
+                            ptcpList = ptcp
+                    else:
+                        main.log.error( self.name + ": Invalid PTCP" )
+                        return main.FALSE
+            else:
+                main.log.error( self.name + ": Invalid switch type " )
+                return main.FALSE
+
+            assignResult = main.TRUE
+            index = 0
+            for switch in switchList:
+                assigned = False
+                switchComponent = self.getSwitchComponentByShortName( switch )
+                if switchComponent:
+                    ptcp = ptcpList[ index ] if ptcpList else ""
+                    assignResult = assignResult and switchComponent.assignSwController( ip=ip, port=port, ptcp=ptcp )
+                    assigned = True
+                if not assigned:
+                    main.log.error( self.name + ": Not able to find switch " + switch )
+                    assignResult = main.FALSE
+                index += 1
+            return assignResult
+
+        except Exception:
+            main.log.exception( self.name + ": Uncaught exception!" )
+            main.cleanAndExit()
+
+    def pingall( self, protocol="IPv4", timeout=300, shortCircuit=False, acceptableFailed=0 ):
+        """
+        Description:
+            Verifies the reachability of the hosts using ping command.
+        Optional:
+            protocol - use ping6 command if specified as "IPv6"
+            timeout( seconds ) - How long to wait before breaking the pingall
+            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
+        """
+        import time
+        import itertools
+        try:
+            timeout = int( timeout )
+            main.log.info( self.name + ": Checking reachabilty to the hosts using ping" )
+            failedPings = 0
+            returnValue = main.TRUE
+            ipv6 = True if protocol == "IPv6" else False
+            startTime = time.time()
+            hostPairs = itertools.permutations( list( self.hosts.values() ), 2 )
+            for hostPair in list( hostPairs ):
+                ipDst = hostPair[ 1 ].options[ 'ip6' ] if ipv6 else hostPair[ 1 ].options[ 'ip' ]
+                pingResult = hostPair[ 0 ].ping( ipDst, ipv6=ipv6 )
+                returnValue = returnValue and pingResult
+                if ( time.time() - startTime ) > timeout:
+                    returnValue = main.FALSE
+                    main.log.error( self.name +
+                                    ": Aborting pingall - " +
+                                    "Function took too long " )
+                    break
+                if not pingResult:
+                    failedPings = failedPings + 1
+                    if failedPings > acceptableFailed:
+                        returnValue = main.FALSE
+                        if shortCircuit:
+                            main.log.error( self.name +
+                                            ": Aborting pingall - "
+                                            + str( failedPings ) +
+                                            " pings failed" )
+                            break
+            return returnValue
+        except Exception:
+            main.log.exception( self.name + ": Uncaught exception!" )
+            main.cleanAndExit()
+
+    def pingallHosts( self, hostList, wait=1 ):
+        """
+            Ping all specified IPv4 hosts
+
+            Acceptable hostList:
+                - [ 'h1','h2','h3','h4' ]
+
+            Returns main.TRUE if all hosts specified can reach
+            each other
+
+            Returns main.FALSE if one or more of hosts specified
+            cannot reach each other"""
+        import time
+        import itertools
+        hostComponentList = []
+        for hostName in hostList:
+            hostComponent = self.getHostComponentByShortName( hostName )
+            if hostComponent:
+                hostComponentList.append( hostComponent )
+        try:
+            main.log.info( "Testing reachability between specified hosts" )
+            isReachable = main.TRUE
+            pingResponse = "IPv4 ping across specified hosts\n"
+            failedPings = 0
+            hostPairs = itertools.permutations( list( hostComponentList ), 2 )
+            for hostPair in list( hostPairs ):
+                pingResponse += hostPair[ 0 ].options[ 'shortName' ] + " -> "
+                ipDst = hostPair[ 1 ].options[ 'ip6' ] if ipv6 else hostPair[ 1 ].options[ 'ip' ]
+                pingResult = hostPair[ 0 ].ping( ipDst, wait=int( wait ) )
+                if pingResult:
+                    pingResponse += hostPair[ 1 ].options[ 'shortName' ]
+                else:
+                    pingResponse += "X"
+                    # One of the host to host pair is unreachable
+                    isReachable = main.FALSE
+                    failedPings += 1
+                pingResponse += "\n"
+            main.log.info( pingResponse + "Failed pings: " + str( failedPings ) )
+            return isReachable
+        except Exception:
+            main.log.exception( self.name + ": Uncaught exception!" )
+            main.cleanAndExit()
+
+    def iperftcp( self, host1="h1", host2="h2", timeout=6 ):
+        '''
+        Creates an iperf TCP test between two hosts. Returns main.TRUE if test results
+        are valid.
+        Optional:
+            timeout: The defualt timeout is 6 sec to allow enough time for a successful test to complete,
+            and short enough to stop an unsuccessful test from quiting and cleaning up mininet.
+        '''
+        main.log.info( self.name + ": Simple iperf TCP test between two hosts" )
+        # TODO: complete this function
+        return main.TRUE
diff --git a/TestON/tests/FUNC/FUNCgroup/FUNCgroup.params b/TestON/tests/FUNC/FUNCgroup/FUNCgroup.params
index 99a8e01..2be846e 100644
--- a/TestON/tests/FUNC/FUNCgroup/FUNCgroup.params
+++ b/TestON/tests/FUNC/FUNCgroup/FUNCgroup.params
@@ -4,13 +4,16 @@
     # 1    - Variable initialization and optional pull and build ONOS package
     # 2    - install ONOS
     # 3    - Start mininet and scapy and verify topology
+    # 11   - Connect to physical network and start scapy
     # 4    - Testing Scapy
     # 5    - Testing GROUP with type "ALL"
     # 6    - Deleting the Group and Flow
     # 7    - Testing GROUP with type "INDIRECT"
     # 8    - Deleting the group and flow
-    # 10    - Stop mininet and scapy
+    # 10   - Stop mininet and scapy
+    # 12   - Stop physical scapy hosts
     # 100  - Check logs for Errors and Warnings
+    # Sample testcases for physical network: 1,2,11,5,6,7,6,12,100
     <testcases>1,2,3,5,6,7,6,10,100</testcases>
 
     <GRAPH>
diff --git a/TestON/tests/FUNC/FUNCgroup/FUNCgroup.py b/TestON/tests/FUNC/FUNCgroup/FUNCgroup.py
index bbe759d..4a83581 100644
--- a/TestON/tests/FUNC/FUNCgroup/FUNCgroup.py
+++ b/TestON/tests/FUNC/FUNCgroup/FUNCgroup.py
@@ -84,15 +84,6 @@
                                             bucket +
                                             ".py" )
 
-            copyResult = main.ONOSbench.scp( main.Mininet1,
-                                             main.dependencyPath + main.topology,
-                                             main.Mininet1.home + '/custom/',
-                                             direction="to" )
-
-            utilities.assert_equals( expect=main.TRUE,
-                                     actual=copyResult,
-                                     onpass="Successfully copy " + "test variables ",
-                                     onfail="Failed to copy test variables" )
             stepResult = main.testSetUp.envSetup()
 
         except Exception as e:
@@ -134,6 +125,16 @@
         main.caseExplanation = "Start mininet with custom topology and compare topology " +\
                 "elements between Mininet and ONOS"
 
+        main.step( "Copy Mininet topology file" )
+        copyResult = main.ONOSbench.scp( main.Mininet1,
+                                         main.dependencyPath + main.topology,
+                                         main.Mininet1.home + '/custom/',
+                                         direction="to" )
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=copyResult,
+                                 onpass="Successfully copy mininet topo file",
+                                 onfail="Failed to copy mininet topo file" )
+
         main.step( "Setup Mininet Topology" )
         topology = main.Mininet1.home + '/custom/' + main.topology
         stepResult = main.Mininet1.startNet( topoFile=topology )
@@ -175,6 +176,52 @@
                                  onpass="Successfully created Scapy Components",
                                  onfail="Failed to discover Scapy Components" )
 
+    def CASE11( self, main ):
+        """
+            Connect to a physical network, assign controllers and start scapy
+        """
+        import time
+        main.case( "Connecting to physical network" )
+
+        main.step( "Connecting to physical network" )
+        topoResult = main.NetworkBench.connectToNet()
+        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.cleanAndExit()
+
+        main.step( "Assign switches to controllers." )
+        assignResult = main.TRUE
+        for i in range( 1, 2 ):
+            assignResult = assignResult & main.NetworkBench.assignSwController( sw="s" + str( i ),
+                                                                                ip=main.Cluster.getIps(),
+                                                                                port='6653' )
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="Successfully assign switches to controllers",
+                                 onfail="Failed to assign switches to controllers" )
+
+        main.step( "Start scapy" )
+        scapyResult = main.TRUE
+        for hostName in main.scapyHostNames:
+            main.scapyHosts.append( getattr( main, hostName ) )
+
+        for host in main.scapyHosts:
+            host.startScapy()
+            host.updateSelf()
+            main.log.debug( host.name )
+            main.log.debug( host.hostIp )
+            main.log.debug( host.hostMac )
+
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=scapyResult,
+                                 onpass="Successfully created Scapy Components",
+                                 onfail="Failed to discover Scapy Components" )
+
     def CASE4( self, main ):
         """
         Testing scapy
@@ -557,6 +604,20 @@
         if not ( mininetResult and scapyResult ):
             main.cleanAndExit()
 
+    def CASE12( self, main ):
+        """
+        Stop Scapy on physical hosts
+        """
+        main.case( "Stop Scapy" )
+        main.step( "Stopping Scapy Hosts" )
+        scapyResult = main.TRUE
+        for host in main.scapyHosts:
+            host.stopScapy()
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=scapyResult,
+                                 onpass="Successfully stopped scapy",
+                                 onfail="Failed to stop scapy" )
+
     def CASE100( self, main ):
         """
             Report errors/warnings/exceptions
diff --git a/TestON/tests/FUNC/FUNCgroup/FUNCgroup.topo.physical b/TestON/tests/FUNC/FUNCgroup/FUNCgroup.topo.physical
new file mode 100644
index 0000000..956d1ef
--- /dev/null
+++ b/TestON/tests/FUNC/FUNCgroup/FUNCgroup.topo.physical
@@ -0,0 +1,154 @@
+<TOPOLOGY>
+    <COMPONENT>
+
+        <ONOScell>
+            <host>localhost</host>  # ONOS "bench" machine
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>OnosClusterDriver</type>
+            <connect_order>1</connect_order>
+            <COMPONENTS>
+                <cluster_name></cluster_name>  # Used as a prefix for cluster components. Defaults to 'ONOS'
+                <diff_clihost></diff_clihost> # if it has different host other than localhost for CLI. True or empty. OC# will be used for True.
+                <karaf_username></karaf_username>
+                <karaf_password></karaf_password>
+                <web_user></web_user>
+                <web_pass></web_pass>
+                <rest_port></rest_port>
+                <prompt></prompt>  # TODO: we technically need a few of these, one per component
+                <onos_home></onos_home>  # defines where onos home is
+                <nodes> 1 </nodes>  # number of nodes in the cluster
+            </COMPONENTS>
+        </ONOScell>
+
+        <MininetSwitch1>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetSwitchDriver</type>
+            <connect_order>2</connect_order>
+            <COMPONENTS>
+                <shortName>s1</shortName>
+                <port1>1</port1>
+                <link1>MininetHost1</link1>
+                <port2>2</port2>
+                <link2>MininetHost2</link2>
+                <port3>3</port3>
+                <link3>MininetHost3</link3>
+                <port4>4</port4>
+                <link4>MininetHost4</link4>
+            </COMPONENTS>
+        </MininetSwitch1>
+
+        <MininetHost1>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>3</connect_order>
+            <COMPONENTS>
+                <ip>10.0.0.1</ip>
+                <shortName>h1</shortName>
+                <port1>0</port1>
+                <link1>MininetSwitch1</link1>
+            </COMPONENTS>
+        </MininetHost1>
+
+        <MininetHost2>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>4</connect_order>
+            <COMPONENTS>
+                <ip>10.0.0.2</ip>
+                <shortName>h2</shortName>
+                <port1>0</port1>
+                <link1>MininetSwitch1</link1>
+            </COMPONENTS>
+        </MininetHost2>
+
+        <MininetHost3>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>5</connect_order>
+            <COMPONENTS>
+                <ip>10.0.0.3</ip>
+                <shortName>h3</shortName>
+                <port1>0</port1>
+                <link1>MininetSwitch1</link1>
+            </COMPONENTS>
+        </MininetHost3>
+
+        <MininetHost4>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>6</connect_order>
+            <COMPONENTS>
+                <ip>10.0.0.4</ip>
+                <shortName>h4</shortName>
+                <port1>0</port1>
+                <link1>MininetSwitch1</link1>
+            </COMPONENTS>
+        </MininetHost4>
+
+        <NetworkBench>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>NetworkDriver</type>
+            <connect_order>7</connect_order>
+            <COMPONENTS>
+            </COMPONENTS>
+        </NetworkBench>
+
+        <h1>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>8</connect_order>
+            <COMPONENTS>
+                <ifaceName>h1-eth0</ifaceName>
+            </COMPONENTS>
+        </h1>
+
+        <h2>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>9</connect_order>
+            <COMPONENTS>
+                <ifaceName>h2-eth0</ifaceName>
+            </COMPONENTS>
+        </h2>
+
+        <h3>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>10</connect_order>
+            <COMPONENTS>
+                <ifaceName>h3-eth0</ifaceName>
+            </COMPONENTS>
+        </h3>
+
+        <h4>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>11</connect_order>
+            <COMPONENTS>
+                <ifaceName>h4-eth0</ifaceName>
+            </COMPONENTS>
+        </h4>
+
+    </COMPONENT>
+</TOPOLOGY>
diff --git a/TestON/tests/FUNC/FUNCintent/FUNCintent.params b/TestON/tests/FUNC/FUNCintent/FUNCintent.params
index 4976a0f..659a02c 100644
--- a/TestON/tests/FUNC/FUNCintent/FUNCintent.params
+++ b/TestON/tests/FUNC/FUNCintent/FUNCintent.params
@@ -14,12 +14,16 @@
     # 17 - Activate Flow Objectives
     # 18 - Stop Mininet
     # 19 - Copy karaf logs from ONOS nodes to TestON log directory
+    # 100 - Connect to physical network and start scapy
+    # 101 - Stop physical scapy hosts
     # 1000 - Test host intents
     # 2000 - Test point intents
     # 3000 - Test single to multi point intents
     # 4000 - Test multi to single point intents
     # 5000 - Test host mobility
     # 6000 - Test Multi Point intent End Point Failure
+    # Sample testcases for physical network: 1,2,100,15,16,1000,2000,3000,4000,6000,101,19
+    # Note: set usePortstate to True for tests with physical switches
 
     <testcases>1,[2,10,12,13,15,16,1000,2000,3000,4000,5000,6000,18,19]*2,[2,10,12,13,15,16,17,1000,2000,3000,4000,5000,6000,18,19]*2,[2,11,12,13,15,16,1000,2000,3000,4000,5000,6000,18,19]*2,[2,11,12,13,15,16,17,1000,2000,3000,4000,5000,6000,18,19]*2</testcases>
 
diff --git a/TestON/tests/FUNC/FUNCintent/FUNCintent.py b/TestON/tests/FUNC/FUNCintent/FUNCintent.py
index c7ae062..bd100f4 100644
--- a/TestON/tests/FUNC/FUNCintent/FUNCintent.py
+++ b/TestON/tests/FUNC/FUNCintent/FUNCintent.py
@@ -440,6 +440,66 @@
             main.Utils = Utils()
         main.Utils.copyKarafLog( "cycle" + str( main.cycle ) )
 
+    def CASE100( self, main):
+        """
+        Connect to a physical network, assign controllers and start scapy
+        """
+        import time
+        main.case( "Connecting to physical network" )
+        main.step( "Connecting to physical network" )
+        main.OFProtocol = "1.3"
+        topoResult = main.NetworkBench.connectToNet()
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=topoResult,
+                                 onpass="Successfully loaded topology",
+                                 onfail="Failed to load topology" )
+        # Exit if topology did not load properly
+        if not topoResult:
+            main.cleanAndExit()
+
+        main.step( "Assign switches to controllers." )
+        assignResult = main.TRUE
+        switchList = []
+        for i in range( 1, ( main.numSwitch + 1 ) ):
+            switchList.append( 's' + str( i ) )
+        tempONOSip = main.Cluster.getIps()
+        assignResult = main.Network.assignSwController( sw=switchList,
+                                                        ip=tempONOSip,
+                                                        port="6653" )
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=assignResult,
+                                 onpass="Successfully assigned switches to controller",
+                                 onfail="Failed to assgin switches to controller" )
+
+        main.step( "Start scapy" )
+        scapyResult = main.TRUE
+        for hostName in main.scapyHostNames:
+            main.scapyHosts.append( getattr( main, hostName ) )
+
+        for host in main.scapyHosts:
+            host.startScapy()
+            host.updateSelf()
+            main.log.debug( host.name )
+            main.log.debug( host.hostIp )
+            main.log.debug( host.hostMac )
+
+        utilities.assert_equals( expect=main.TRUE, actual=scapyResult,
+                                 onpass="Successfully created Scapy Components",
+                                 onfail="Failed to discover Scapy Components" )
+
+    def CASE101( self, main ):
+        """
+        Stop Scapy on physical hosts
+        """
+        main.case( "Stop Scapy" )
+        main.step( "Stopping Scapy Hosts" )
+        scapyResult = main.TRUE
+        for host in main.scapyHosts:
+            host.stopScapy()
+        utilities.assert_equals( expect=main.TRUE, actual=scapyResult,
+                                 onpass="Successfully stopped scapy",
+                                 onfail="Failed to stop scapy" )
+
     def CASE1000( self, main ):
         """
             Add host intents between 2 host:
diff --git a/TestON/tests/FUNC/FUNCintent/FUNCintent.topo.physical b/TestON/tests/FUNC/FUNCintent/FUNCintent.topo.physical
new file mode 100755
index 0000000..0407aa2
--- /dev/null
+++ b/TestON/tests/FUNC/FUNCintent/FUNCintent.topo.physical
@@ -0,0 +1,723 @@
+<TOPOLOGY>
+    <COMPONENT>
+
+        <ONOScell>
+            <host>localhost</host>  # ONOS "bench" machine
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>OnosClusterDriver</type>
+            <connect_order>1</connect_order>
+            <COMPONENTS>
+                <cluster_name></cluster_name>  # Used as a prefix for cluster components. Defaults to 'ONOS'
+                <diff_clihost></diff_clihost> # if it has different host other than localhost for CLI. True or empty. OC# will be used for True.
+                <karaf_username></karaf_username>
+                <karaf_password></karaf_password>
+                <web_user></web_user>
+                <web_pass></web_pass>
+                <rest_port></rest_port>
+                <prompt></prompt>  # TODO: we technically need a few of these, one per component
+                <onos_home></onos_home>  # defines where onos home is
+                <nodes> 3 </nodes>  # number of nodes in the cluster
+            </COMPONENTS>
+        </ONOScell>
+
+        <MininetSwitch1>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetSwitchDriver</type>
+            <connect_order>2</connect_order>
+            <COMPONENTS>
+                <shortName>s1</shortName>
+                <link1>MininetSwitch2</link1>
+                <link2>MininetSwitch3</link2>
+                <link3>MininetSwitch4</link3>
+                <link4>MininetSwitch5</link4>
+            </COMPONENTS>
+        </MininetSwitch1>
+
+        <MininetSwitch2>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetSwitchDriver</type>
+            <connect_order>3</connect_order>
+            <COMPONENTS>
+                <shortName>s2</shortName>
+                <link1>MininetSwitch1</link1>
+                <link2>MininetSwitch3</link2>
+                <link3>MininetSwitch5</link3>
+                <link4>MininetSwitch6</link4>
+            </COMPONENTS>
+        </MininetSwitch2>
+
+        <MininetSwitch3>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetSwitchDriver</type>
+            <connect_order>4</connect_order>
+            <COMPONENTS>
+                <shortName>s3</shortName>
+                <link1>MininetSwitch1</link1>
+                <link2>MininetSwitch2</link2>
+                <link3>MininetSwitch4</link3>
+                <link4>MininetSwitch6</link4>
+            </COMPONENTS>
+        </MininetSwitch3>
+
+        <MininetSwitch4>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetSwitchDriver</type>
+            <connect_order>5</connect_order>
+            <COMPONENTS>
+                <shortName>s4</shortName>
+                <link1>MininetSwitch1</link1>
+                <link2>MininetSwitch3</link2>
+                <link3>MininetSwitch7</link3>
+            </COMPONENTS>
+        </MininetSwitch4>
+
+        <MininetSwitch5>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetSwitchDriver</type>
+            <connect_order>6</connect_order>
+            <COMPONENTS>
+                <shortName>s5</shortName>
+                <link1>MininetHost1</link1>
+                <link2>MininetHost2</link2>
+                <link3>MininetHost3</link3>
+                <link4>MininetHost4</link4>
+                <link5>MininetHost5</link5>
+                <link6>MininetHost6</link6>
+                <link7>MininetHost7</link7>
+                <link8>MininetHost8</link8>
+                <link9>MininetSwitch1</link9>
+                <link10>MininetSwitch2</link10>
+            </COMPONENTS>
+        </MininetSwitch5>
+
+        <MininetSwitch6>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetSwitchDriver</type>
+            <connect_order>7</connect_order>
+            <COMPONENTS>
+                <shortName>s6</shortName>
+                <link1>MininetHost9</link1>
+                <link2>MininetHost10</link2>
+                <link3>MininetHost11</link3>
+                <link4>MininetHost12</link4>
+                <link5>MininetHost13</link5>
+                <link6>MininetHost14</link6>
+                <link7>MininetHost15</link7>
+                <link8>MininetHost16</link8>
+                <link9>MininetSwitch2</link9>
+                <link10>MininetSwitch3</link10>
+            </COMPONENTS>
+        </MininetSwitch6>
+
+        <MininetSwitch7>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetSwitchDriver</type>
+            <connect_order>8</connect_order>
+            <COMPONENTS>
+                <shortName>s7</shortName>
+                <link1>MininetHost17</link1>
+                <link2>MininetHost18</link2>
+                <link3>MininetHost19</link3>
+                <link4>MininetHost20</link4>
+                <link5>MininetHost21</link5>
+                <link6>MininetHost22</link6>
+                <link7>MininetHost23</link7>
+                <link8>MininetHost24</link8>
+                <link9>MininetSwitch4</link9>
+            </COMPONENTS>
+        </MininetSwitch7>
+
+        <MininetHost1>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>9</connect_order>
+            <COMPONENTS>
+                <ip>10.1.0.2</ip>
+                <shortName>h1</shortName>
+            </COMPONENTS>
+        </MininetHost1>
+
+        <MininetHost2>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>10</connect_order>
+            <COMPONENTS>
+                <ip6>1000::2</ip6>
+                <shortName>h2</shortName>
+            </COMPONENTS>
+        </MininetHost2>
+
+        <MininetHost3>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>11</connect_order>
+            <COMPONENTS>
+                <ip>10.1.0.3</ip>
+                <ip6>2000::2</ip6>
+                <shortName>h3</shortName>
+            </COMPONENTS>
+        </MininetHost3>
+
+        <MininetHost4>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>12</connect_order>
+            <COMPONENTS>
+                <ip>100.1.0.2</ip>
+                <ip6>3000::2</ip6>
+                <vlan>100</vlan>
+                <shortName>h4</shortName>
+            </COMPONENTS>
+        </MininetHost4>
+
+        <MininetHost5>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>13</connect_order>
+            <COMPONENTS>
+                <ip>200.1.0.2</ip>
+                <ip6>4000::2</ip6>
+                <vlan>200</vlan>
+                <shortName>h5</shortName>
+            </COMPONENTS>
+        </MininetHost5>
+
+        <MininetHost6>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>14</connect_order>
+            <COMPONENTS>
+                <ip>11.1.0.2</ip>
+                <shortName>h6</shortName>
+            </COMPONENTS>
+        </MininetHost6>
+
+        <MininetHost7>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>15</connect_order>
+            <COMPONENTS>
+                <ip>12.1.0.2</ip>
+                <shortName>h7</shortName>
+            </COMPONENTS>
+        </MininetHost7>
+
+        <MininetHost8>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>16</connect_order>
+            <COMPONENTS>
+                <ip>10.1.0.4</ip>
+                <shortName>h8</shortName>
+            </COMPONENTS>
+        </MininetHost8>
+
+        <MininetHost9>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>17</connect_order>
+            <COMPONENTS>
+                <ip>10.1.0.5</ip>
+                <shortName>h9</shortName>
+            </COMPONENTS>
+        </MininetHost9>
+
+        <MininetHost10>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>18</connect_order>
+            <COMPONENTS>
+                <ip6>1000::3</ip6>
+                <shortName>h10</shortName>
+            </COMPONENTS>
+        </MininetHost10>
+
+        <MininetHost11>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>19</connect_order>
+            <COMPONENTS>
+                <ip>10.1.0.6</ip>
+                <ip6>2000::3</ip6>
+                <shortName>h11</shortName>
+            </COMPONENTS>
+        </MininetHost11>
+
+        <MininetHost12>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>20</connect_order>
+            <COMPONENTS>
+                <ip>100.1.0.3</ip>
+                <ip6>3000::3</ip6>
+                <vlan>100</vlan>
+                <shortName>h12</shortName>
+            </COMPONENTS>
+        </MininetHost12>
+
+        <MininetHost13>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>21</connect_order>
+            <COMPONENTS>
+                <ip>200.1.0.3</ip>
+                <ip6>4000::3</ip6>
+                <vlan>200</vlan>
+                <shortName>h13</shortName>
+            </COMPONENTS>
+        </MininetHost13>
+
+        <MininetHost14>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>22</connect_order>
+            <COMPONENTS>
+                <ip>11.1.0.3</ip>
+                <shortName>h14</shortName>
+            </COMPONENTS>
+        </MininetHost14>
+
+        <MininetHost15>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>23</connect_order>
+            <COMPONENTS>
+                <ip>12.1.0.3</ip>
+                <shortName>h15</shortName>
+            </COMPONENTS>
+        </MininetHost15>
+
+        <MininetHost16>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>24</connect_order>
+            <COMPONENTS>
+                <ip>10.1.0.7</ip>
+                <shortName>h16</shortName>
+            </COMPONENTS>
+        </MininetHost16>
+
+        <MininetHost17>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>25</connect_order>
+            <COMPONENTS>
+                <ip>10.1.0.8</ip>
+                <shortName>h17</shortName>
+            </COMPONENTS>
+        </MininetHost17>
+
+        <MininetHost18>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>26</connect_order>
+            <COMPONENTS>
+                <ip6>1000::4</ip6>
+                <shortName>h18</shortName>
+            </COMPONENTS>
+        </MininetHost18>
+
+        <MininetHost19>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>27</connect_order>
+            <COMPONENTS>
+                <ip>10.1.0.9</ip>
+                <ip6>2000::4</ip6>
+                <shortName>h19</shortName>
+            </COMPONENTS>
+        </MininetHost19>
+
+        <MininetHost20>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>28</connect_order>
+            <COMPONENTS>
+                <ip>100.1.0.4</ip>
+                <ip6>3000::4</ip6>
+                <vlan>100</vlan>
+                <shortName>h20</shortName>
+            </COMPONENTS>
+        </MininetHost20>
+
+        <MininetHost21>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>29</connect_order>
+            <COMPONENTS>
+                <ip>200.1.0.4</ip>
+                <ip6>4000::4</ip6>
+                <vlan>200</vlan>
+                <shortName>h21</shortName>
+            </COMPONENTS>
+        </MininetHost21>
+
+        <MininetHost22>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>30</connect_order>
+            <COMPONENTS>
+                <ip>11.1.0.4</ip>
+                <shortName>h22</shortName>
+            </COMPONENTS>
+        </MininetHost22>
+
+        <MininetHost23>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>31</connect_order>
+            <COMPONENTS>
+                <ip>12.1.0.4</ip>
+                <shortName>h23</shortName>
+            </COMPONENTS>
+        </MininetHost23>
+
+        <MininetHost24>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>32</connect_order>
+            <COMPONENTS>
+                <ip>10.1.0.10</ip>
+                <shortName>h24</shortName>
+            </COMPONENTS>
+        </MininetHost24>
+
+        <h1>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>33</connect_order>
+            <COMPONENTS>
+                <ifaceName>h1-eth0</ifaceName>
+            </COMPONENTS>
+        </h1>
+
+        <h2>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>34</connect_order>
+            <COMPONENTS>
+                <ifaceName>h2-eth0</ifaceName>
+            </COMPONENTS>
+        </h2>
+
+        <h3>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>35</connect_order>
+            <COMPONENTS>
+                <ifaceName>h3-eth0</ifaceName>
+            </COMPONENTS>
+        </h3>
+
+        <h4>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>36</connect_order>
+            <COMPONENTS>
+                <ifaceName>h4-eth0</ifaceName>
+            </COMPONENTS>
+        </h4>
+
+        <h5>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>37</connect_order>
+            <COMPONENTS>
+                <ifaceName>h5-eth0</ifaceName>
+            </COMPONENTS>
+        </h5>
+
+        <h6>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>38</connect_order>
+            <COMPONENTS>
+                <ifaceName>h6-eth0</ifaceName>
+            </COMPONENTS>
+        </h6>
+
+        <h7>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>39</connect_order>
+            <COMPONENTS>
+                <ifaceName>h7-eth0</ifaceName>
+            </COMPONENTS>
+        </h7>
+
+        <h8>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>40</connect_order>
+            <COMPONENTS>
+                <ifaceName>h8-eth0</ifaceName>
+            </COMPONENTS>
+        </h8>
+
+        <h9>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>41</connect_order>
+            <COMPONENTS>
+                <ifaceName>h9-eth0</ifaceName>
+            </COMPONENTS>
+        </h9>
+
+        <h10>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>42</connect_order>
+            <COMPONENTS>
+                <ifaceName>h10-eth0</ifaceName>
+            </COMPONENTS>
+        </h10>
+
+        <h11>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>43</connect_order>
+            <COMPONENTS>
+                <ifaceName>h11-eth0</ifaceName>
+            </COMPONENTS>
+        </h11>
+
+        <h12>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>44</connect_order>
+            <COMPONENTS>
+                <ifaceName>h12-eth0</ifaceName>
+            </COMPONENTS>
+        </h12>
+
+        <h13>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>45</connect_order>
+            <COMPONENTS>
+                <ifaceName>h13-eth0</ifaceName>
+            </COMPONENTS>
+        </h13>
+
+        <h14>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>46</connect_order>
+            <COMPONENTS>
+                <ifaceName>h14-eth0</ifaceName>
+            </COMPONENTS>
+        </h14>
+
+        <h15>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>47</connect_order>
+            <COMPONENTS>
+                <ifaceName>h15-eth0</ifaceName>
+            </COMPONENTS>
+        </h15>
+
+        <h16>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>48</connect_order>
+            <COMPONENTS>
+                <ifaceName>h16-eth0</ifaceName>
+            </COMPONENTS>
+        </h16>
+
+        <h17>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>49</connect_order>
+            <COMPONENTS>
+                <ifaceName>h17-eth0</ifaceName>
+            </COMPONENTS>
+        </h17>
+
+        <h18>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>50</connect_order>
+            <COMPONENTS>
+                <ifaceName>h18-eth0</ifaceName>
+            </COMPONENTS>
+        </h18>
+
+        <h19>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>51</connect_order>
+            <COMPONENTS>
+                <ifaceName>h19-eth0</ifaceName>
+            </COMPONENTS>
+        </h19>
+
+        <h20>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>52</connect_order>
+            <COMPONENTS>
+                <ifaceName>h20-eth0</ifaceName>
+            </COMPONENTS>
+        </h20>
+
+        <h21>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>53</connect_order>
+            <COMPONENTS>
+                <ifaceName>h21-eth0</ifaceName>
+            </COMPONENTS>
+        </h21>
+
+        <h22>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>54</connect_order>
+            <COMPONENTS>
+                <ifaceName>h22-eth0</ifaceName>
+            </COMPONENTS>
+        </h22>
+
+        <h23>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>55</connect_order>
+            <COMPONENTS>
+                <ifaceName>h23-eth0</ifaceName>
+            </COMPONENTS>
+        </h23>
+
+        <h24>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostScapyCliDriver</type>
+            <connect_order>56</connect_order>
+            <COMPONENTS>
+                <ifaceName>h24-eth0</ifaceName>
+            </COMPONENTS>
+        </h24>
+
+        <NetworkBench>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>NetworkDriver</type>
+            <connect_order>57</connect_order>
+            <COMPONENTS>
+            </COMPONENTS>
+        </NetworkBench>
+
+    </COMPONENT>
+</TOPOLOGY>
diff --git a/TestON/tests/SAMP/SAMPstartTemplate_3node/SAMPstartTemplate_3node.params b/TestON/tests/SAMP/SAMPstartTemplate_3node/SAMPstartTemplate_3node.params
index 0eead29..73759e5 100755
--- a/TestON/tests/SAMP/SAMPstartTemplate_3node/SAMPstartTemplate_3node.params
+++ b/TestON/tests/SAMP/SAMPstartTemplate_3node/SAMPstartTemplate_3node.params
@@ -5,12 +5,14 @@
         CASE2: get onos warnings, errors from log
         CASE10: start a 3-node ONOS Cluster
         CASE11: Start Mininet and assign controllers
-        CASE12: Sample case of using onos cli
-        CASE22: Sample case of using onos rest
-        CASE32: Configure fwd apps
+        CASE12: Connect to a physical network and assign controllers
+        CASE20: Sample case of using onos cli
+        CASE30: Sample case of using onos rest
+        CASE40: Configure fwd apps and run pingall
+        Sample testcases for physical network: 0,1,10,12,20,30,40,2
    -->
 
-    <testcases>0,1,10,11,12,22,2,32</testcases>
+    <testcases>0,1,10,11,20,30,40,2</testcases>
     <GIT>
         <pull>False</pull>
         <branch>master</branch>
diff --git a/TestON/tests/SAMP/SAMPstartTemplate_3node/SAMPstartTemplate_3node.py b/TestON/tests/SAMP/SAMPstartTemplate_3node/SAMPstartTemplate_3node.py
index 21d86d4..a8634ae 100644
--- a/TestON/tests/SAMP/SAMPstartTemplate_3node/SAMPstartTemplate_3node.py
+++ b/TestON/tests/SAMP/SAMPstartTemplate_3node/SAMPstartTemplate_3node.py
@@ -137,7 +137,7 @@
         main.case( "Start Mininet topology" )
 
         main.step( "Starting Mininet Topology" )
-        topoResult = main.Network.startNet( mnCmd=topology )
+        topoResult = main.Mininet1.startNet( mnCmd=topology )
         stepResult = topoResult
         utilities.assert_equals( expect=main.TRUE,
                                  actual=stepResult,
@@ -150,7 +150,7 @@
         main.step( "Assign switches to controllers." )
         assignResult = main.TRUE
         for i in range( 1, 8 ):
-            assignResult = assignResult & main.Network.assignSwController( sw="s" + str( i ),
+            assignResult = assignResult & main.Mininet1.assignSwController( sw="s" + str( i ),
                                                                             ip=main.Cluster.getIps(),
                                                                             port='6653' )
         time.sleep( main.mnCfgSleep )
@@ -161,13 +161,42 @@
 
     def CASE12( self, main ):
         """
+            Connect to a physical network and assign controllers
+        """
+        main.case( "Connecting to physical network" )
+
+        main.step( "Connecting to physical network" )
+        topoResult = main.NetworkBench.connectToNet()
+        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.cleanAndExit()
+
+        main.step( "Assign switches to controllers." )
+        assignResult = main.TRUE
+        for i in range( 1, 2 ):
+            assignResult = assignResult & main.NetworkBench.assignSwController( sw="s" + str( i ),
+                                                                                ip=main.Cluster.getIps(),
+                                                                                port='6653' )
+        time.sleep( main.mnCfgSleep )
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="Successfully assign switches to controllers",
+                                 onfail="Failed to assign switches to controllers" )
+
+    def CASE20( self, main ):
+        """
             Tests using through ONOS CLI handles
         """
         main.case( "Test some onos commands through CLI. " )
         main.log.debug( main.Cluster.active( 0 ).CLI.sendline( "summary" ) )
         main.log.debug( main.Cluster.active( 1 ).CLI.sendline( "devices" ) )
 
-    def CASE22( self, main ):
+    def CASE30( self, main ):
         """
             Tests using ONOS REST API handles
         """
@@ -175,7 +204,7 @@
         main.log.debug( main.Cluster.active( 0 ).REST.send( "/devices" ) )
         main.log.debug( main.Cluster.active( 2 ).REST.apps() )
 
-    def CASE32( self, main ):
+    def CASE40( self, main ):
         """
             Configure fwd app from .params json string with parameter configured
             Check if configuration successful
diff --git a/TestON/tests/SAMP/SAMPstartTemplate_3node/SAMPstartTemplate_3node.topo.physical b/TestON/tests/SAMP/SAMPstartTemplate_3node/SAMPstartTemplate_3node.topo.physical
new file mode 100755
index 0000000..5409afd
--- /dev/null
+++ b/TestON/tests/SAMP/SAMPstartTemplate_3node/SAMPstartTemplate_3node.topo.physical
@@ -0,0 +1,82 @@
+<TOPOLOGY>
+    <COMPONENT>
+    <!--
+        This is a list of all components and their handles in the test setup.
+        Even with some handles not used in test cases, we want to define
+        all onos cells here, for cases to set up onos cluster.
+    -->
+        <ONOScell>
+            <host>localhost</host>  # ONOS "bench" machine
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>OnosClusterDriver</type>
+            <connect_order>1</connect_order>
+            <COMPONENTS>
+                <cluster_name></cluster_name>  # Used as a prefix for cluster components. Defaults to 'ONOS'
+                <diff_clihost></diff_clihost> # if it has different host other than localhost for CLI. True or empty. OC# will be used if True.
+                <karaf_username></karaf_username>
+                <karaf_password></karaf_password>
+                <web_user></web_user>
+                <web_pass></web_pass>
+                <rest_port></rest_port>
+                <prompt></prompt>  # TODO: we technically need a few of these, one per component
+                <onos_home></onos_home>  # defines where onos home is
+                <nodes> 3 </nodes>  # number of nodes in the cluster
+            </COMPONENTS>
+        </ONOScell>
+
+        <MininetSwitch1>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetSwitchDriver</type>
+            <connect_order>2</connect_order>
+            <COMPONENTS>
+                <shortName>s1</shortName>
+                <port1>1</port1>
+                <link1>MininetHost1</link1>
+                <port2>2</port2>
+                <link2>MininetHost2</link2>
+            </COMPONENTS>
+        </MininetSwitch1>
+
+        <MininetHost1>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>3</connect_order>
+            <COMPONENTS>
+                <ip>10.0.0.1</ip>
+                <shortName>h1</shortName>
+                <port1>0</port1>
+                <link1>MininetSwitch1</link1>
+            </COMPONENTS>
+        </MininetHost1>
+
+        <MininetHost2>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>4</connect_order>
+            <COMPONENTS>
+                <ip>10.0.0.2</ip>
+                <shortName>h2</shortName>
+                <port1>0</port1>
+                <link1>MininetSwitch1</link1>
+            </COMPONENTS>
+        </MininetHost2>
+
+        <NetworkBench>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>NetworkDriver</type>
+            <connect_order>5</connect_order>
+            <COMPONENTS>
+            </COMPONENTS>
+        </NetworkBench>
+
+    </COMPONENT>
+</TOPOLOGY>
diff --git a/TestON/tests/USECASE/SegmentRouting/SRBridging/SRBridging.params b/TestON/tests/USECASE/SegmentRouting/SRBridging/SRBridging.params
index 09d8b19..0fbda47 100644
--- a/TestON/tests/USECASE/SegmentRouting/SRBridging/SRBridging.params
+++ b/TestON/tests/USECASE/SegmentRouting/SRBridging/SRBridging.params
@@ -1,4 +1,5 @@
 <PARAMS>
+    # Sample testcase for physical network: 7
     <testcases>5,6,7,8,15,16,17,18,25,26,27,28,35,36,37,38,45,46,47,48,55,56,57,58,65,66,67,68,75,76,77,78</testcases>
 
     <GRAPH>
diff --git a/TestON/tests/USECASE/SegmentRouting/SRBridging/SRBridging.topo.physical b/TestON/tests/USECASE/SegmentRouting/SRBridging/SRBridging.topo.physical
new file mode 100644
index 0000000..4605185
--- /dev/null
+++ b/TestON/tests/USECASE/SegmentRouting/SRBridging/SRBridging.topo.physical
@@ -0,0 +1,158 @@
+<TOPOLOGY>
+    <COMPONENT>
+        <ONOScell>
+            <host>localhost</host>  # ONOS "bench" machine
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>OnosClusterDriver</type>
+            <connect_order>1</connect_order>
+            <COMPONENTS>
+                <cluster_name></cluster_name>  # Used as a prefix for cluster components. Defaults to 'ONOS'
+                <diff_clihost></diff_clihost> # if it has different host other than localhost for CLI. True or empty. OC# will be used if True.
+                <karaf_username></karaf_username>
+                <karaf_password></karaf_password>
+                <web_user></web_user>
+                <web_pass></web_pass>
+                <rest_port></rest_port>
+                <prompt></prompt>  # TODO: we technically need a few of these, one per component
+                <onos_home></onos_home>  # defines where onos home is
+                <nodes>3</nodes>  # number of nodes in the cluster
+            </COMPONENTS>
+        </ONOScell>
+
+        <MininetSwitchLeaf1>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetSwitchDriver</type>
+            <connect_order>2</connect_order>
+            <COMPONENTS>
+                <shortName>leaf1</shortName>
+                <port1>1</port1>
+                <link1>MininetSwitchSpine101</link1>
+                <port2>2</port2>
+                <link2>MininetSwitchSpine102</link2>
+                <port3>3</port3>
+                <link3>MininetHost1</link3>
+                <port4>4</port4>
+                <link4>MininetHost2</link4>
+            </COMPONENTS>
+        </MininetSwitchLeaf1>
+
+        <MininetSwitchLeaf2>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetSwitchDriver</type>
+            <connect_order>3</connect_order>
+            <COMPONENTS>
+                <shortName>leaf2</shortName>
+                <port1>1</port1>
+                <link1>MininetSwitchSpine101</link1>
+                <port2>2</port2>
+                <link2>MininetSwitchSpine102</link2>
+                <port3>3</port3>
+                <link3>MininetHost3</link3>
+                <port4>4</port4>
+                <link4>MininetHost4</link4>
+            </COMPONENTS>
+        </MininetSwitchLeaf2>
+
+        <MininetSwitchSpine101>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetSwitchDriver</type>
+            <connect_order>4</connect_order>
+            <COMPONENTS>
+                <shortName>spine101</shortName>
+                <port1>1</port1>
+                <link1>MininetSwitchLeaf1</link1>
+                <port2>2</port2>
+                <link2>MininetSwitchLeaf2</link2>
+            </COMPONENTS>
+        </MininetSwitchSpine101>
+
+        <MininetSwitchSpine102>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetSwitchDriver</type>
+            <connect_order>5</connect_order>
+            <COMPONENTS>
+                <shortName>spine102</shortName>
+                <port1>1</port1>
+                <link1>MininetSwitchLeaf1</link1>
+                <port2>2</port2>
+                <link2>MininetSwitchLeaf2</link2>
+            </COMPONENTS>
+        </MininetSwitchSpine102>
+
+        <MininetHost1>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>6</connect_order>
+            <COMPONENTS>
+                <ip>10.0.2.1</ip>
+                <shortName>h1</shortName>
+                <port1>0</port1>
+                <link1>MininetSwitchLeaf1</link1>
+            </COMPONENTS>
+        </MininetHost1>
+
+        <MininetHost2>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>7</connect_order>
+            <COMPONENTS>
+                <ip>10.0.2.2</ip>
+                <shortName>h2</shortName>
+                <port1>0</port1>
+                <link1>MininetSwitchLeaf1</link1>
+            </COMPONENTS>
+        </MininetHost2>
+
+        <MininetHost3>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>8</connect_order>
+            <COMPONENTS>
+                <ip>10.0.3.1</ip>
+                <shortName>h3</shortName>
+                <port1>0</port1>
+                <link1>MininetSwitchLeaf2</link1>
+            </COMPONENTS>
+        </MininetHost3>
+
+        <MininetHost4>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetHostDriver</type>
+            <connect_order>9</connect_order>
+            <COMPONENTS>
+                <ip>10.0.3.2</ip>
+                <shortName>h4</shortName>
+                <port1>0</port1>
+                <link1>MininetSwitchLeaf2</link1>
+            </COMPONENTS>
+        </MininetHost4>
+
+        <NetworkBench>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>NetworkDriver</type>
+            <connect_order>10</connect_order>
+            <COMPONENTS>
+            </COMPONENTS>
+        </NetworkBench>
+
+    </COMPONENT>
+</TOPOLOGY>
diff --git a/TestON/tests/USECASE/SegmentRouting/SRBridging/dependencies/SRBridgingTest.py b/TestON/tests/USECASE/SegmentRouting/SRBridging/dependencies/SRBridgingTest.py
index 6b869c1..fa496dd 100644
--- a/TestON/tests/USECASE/SegmentRouting/SRBridging/dependencies/SRBridgingTest.py
+++ b/TestON/tests/USECASE/SegmentRouting/SRBridging/dependencies/SRBridgingTest.py
@@ -36,6 +36,8 @@
         # TODO: Implement 2x3 topology
         # topo[ '2x3' ] = ( 2, 3, True, '2x3 leaf-spine topology with dual ToR and single ToR', 28 )
         topo[ '2x4' ] = ( 2, 4, True, '2x4 dual-homed leaf-spine topology', 53 )
+        switchNames = {}
+        switchNames[ '2x2' ] = [ "leaf1", "leaf2", "spine101", "spine102" ]
 
         skipPackage = False
         init = False
@@ -64,8 +66,7 @@
             run.startMininet( main, 'trellis_fabric.py', args=mininet_args )
         else:
             # Run the test with physical devices
-            # TODO: connect TestON to the physical network
-            pass
+            run.connectToPhysicalNetwork( main, switchNames[ topology ] )
 
         run.checkFlows( main, minFlowCount=topo[ topology ][ 4 ] * topo[ topology ][ 1 ], sleep=5 )
         leaf_dpid = [ "of:%016d" % ( ls + 1 ) for ls in range( topo[ topology ][ 1 ] ) ]
diff --git a/TestON/tests/USECASE/SegmentRouting/dependencies/Testcaselib.py b/TestON/tests/USECASE/SegmentRouting/dependencies/Testcaselib.py
index a5106be..bc021c6 100644
--- a/TestON/tests/USECASE/SegmentRouting/dependencies/Testcaselib.py
+++ b/TestON/tests/USECASE/SegmentRouting/dependencies/Testcaselib.py
@@ -166,6 +166,30 @@
             main.cleanAndExit()
 
     @staticmethod
+    def connectToPhysicalNetwork( main, switchNames ):
+        main.step( "Connecting to physical netowrk" )
+        topoResult = main.NetworkBench.connectToNet()
+        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.cleanAndExit()
+
+        main.step( "Assign switches to controllers." )
+        assignResult = main.TRUE
+        for name in switchNames:
+            assignResult = assignResult & main.NetworkBench.assignSwController( sw=name,
+                                                                                ip=main.Cluster.getIps(),
+                                                                                port='6653' )
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="Successfully assign switches to controllers",
+                                 onfail="Failed to assign switches to controllers" )
+
+    @staticmethod
     def config( main, cfgName ):
         main.spines = []