diff --git a/TestON/drivers/common/cli/onosdriver.py b/TestON/drivers/common/cli/onosdriver.py
index 8890871..89dc363 100755
--- a/TestON/drivers/common/cli/onosdriver.py
+++ b/TestON/drivers/common/cli/onosdriver.py
@@ -2668,111 +2668,3 @@
         except Exception:
             main.log.exception( self.name + ": Uncaught exception!" )
             main.cleanAndExit()
-
-    def atomixKill( self, nodeIp ):
-        """
-        Calls the command: 'atomix-kill [<node-ip>]'
-        Kills the Atomix instance running on the specified node
-        """
-        try:
-            self.handle.sendline( "" )
-            self.handle.expect( self.prompt )
-            self.handle.sendline( "atomix-kill " + str( nodeIp ) )
-            i = self.handle.expect( [
-                self.prompt,
-                "No\sroute\sto\shost",
-                "password:",
-                pexpect.TIMEOUT ], timeout=60 )
-
-            if i == 0:
-                main.log.info( "Atomix instance " + str( nodeIp ) + " was killed" )
-                return main.TRUE
-            elif i == 1:
-                main.log.info( "No route to host" )
-                return main.FALSE
-            elif i == 2:
-                main.log.info( "Passwordless login for host: " + str( nodeIp ) + " not configured" )
-                return main.FALSE
-            else:
-                main.log.info( "Atomix instance was not killed" )
-                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 atomixUninstall( self, nodeIp="" ):
-        """
-        Calls the command: 'atomix-uninstall'
-        Uninstalls Atomix from the designated node, stopping if needed
-        """
-        try:
-            self.handle.sendline( "" )
-            self.handle.expect( self.prompt, timeout=180 )
-            self.handle.sendline( "atomix-uninstall " + str( nodeIp ) )
-            self.handle.expect( self.prompt, timeout=180 )
-            main.log.info( "Atomix " + nodeIp + " was uninstalled" )
-            # onos-uninstall command does not return any text
-            return main.TRUE
-        except pexpect.TIMEOUT:
-            main.log.exception( self.name + ": Timeout in atomixUninstall" )
-            self.handle.send( "\x03" )  # Control-C
-            self.handle.expect( self.prompt )
-            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 atomixInstall( self, options="", node="" ):
-        """
-        Installs Atomix on the designated nodes.
-        Returns: main.TRUE on success and main.FALSE on failure
-        """
-        try:
-            if options:
-                self.handle.sendline( "atomix-install " + options + " " + node )
-            else:
-                self.handle.sendline( "atomix-install " + node )
-            self.handle.expect( "atomix-install " )
-            i = self.handle.expect( [ "Network\sis\sunreachable",
-                                      "is already installed",
-                                      "saved",
-                                      self.prompt,
-                                      pexpect.TIMEOUT ], timeout=180 )
-            if i == 0:
-                # can't reach ONOS node
-                main.log.warn( "Network is unreachable" )
-                self.handle.expect( self.prompt )
-                return main.FALSE
-            elif i == 1:
-                # same bits are already on Atomix node
-                main.log.info( "Atomix is already installed on " + node )
-                self.handle.expect( self.prompt )
-                return main.TRUE
-            elif i == 2 or i == 3:
-                main.log.info( "Atomix was installed on " + node )
-                self.handle.expect( self.prompt )
-                return main.TRUE
-            elif i == 4:
-                # timeout
-                main.log.info( "Installation of Atomix on " + node + " timed out" )
-                self.handle.expect( self.prompt )
-                main.log.warn( self.handle.before )
-                self.handle.send( "\x03" )  # Control-C
-                self.handle.expect( self.prompt )
-                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/tests/dependencies/Cluster.py b/TestON/tests/dependencies/Cluster.py
index 6bfbb3f..a67bad5 100644
--- a/TestON/tests/dependencies/Cluster.py
+++ b/TestON/tests/dependencies/Cluster.py
@@ -176,27 +176,7 @@
                       specificDriver=1,
                       getFrom=0 if installMax else 1 )
 
-    def uninstallAtomix( self, uninstallMax ):
-        """
-        Description:
-            uninstalling atomix
-        Required:
-            * uninstallMax - True for uninstalling max number of nodes
-            False for uninstalling the current running nodes.
-        Returns:
-            Returns main.TRUE if it successfully uninstalled.
-        """
-        result = main.TRUE
-        uninstallResult = self.command( "atomixUninstall",
-                                        kwargs={ "nodeIp": "ipAddress" },
-                                        specificDriver=1,
-                                        getFrom=0 if uninstallMax else 1,
-                                        funcFromCtrl=True )
-        for uninstallR in uninstallResult:
-            result = result and uninstallR
-        return result
-
-    def uninstallOnos( self, uninstallMax ):
+    def uninstall( self, uninstallMax ):
         """
         Description:
             uninstalling onos
@@ -264,31 +244,7 @@
                 main.log.warn( ctrl.name + " may not be up." )
         return onosIsUp
 
-    def killAtomix( self, killMax, stopAtomix ):
-        """
-        Description:
-            killing atomix. It will either kill the current runningnodes or
-            max number of the nodes.
-        Required:
-            * killRemoveMax - The boolean that will decide either to kill
-            only running nodes ( False ) or max number of nodes ( True ).
-            * stopAtomix - If wish to atomix onos before killing it. True for
-            enable stop, False for disable stop.
-        Returns:
-            Returns main.TRUE if successfully killing it.
-        """
-        result = main.TRUE
-        killResult = self.command( "atomixKill",
-                                   args=[ "ipAddress" ],
-                                   specificDriver=1,
-                                   getFrom=0 if killMax else 1,
-                                   funcFromCtrl=True )
-        for i in range( len( killResult ) ):
-            result = result and killResult[ i ]
-            self.controllers[ i ].active = False
-        return result
-
-    def killOnos( self, killMax, stopOnos ):
+    def kill( self, killMax, stopOnos ):
         """
         Description:
             killing the onos. It will either kill the current runningnodes or
@@ -331,42 +287,7 @@
             result = result and sshR
         return result
 
-    def installAtomix( self, installMax=True, installParallel=True ):
-        """
-        Description:
-            Installing onos.
-        Required:
-            * installMax - True for installing max number of nodes
-            False for installing current running nodes only.
-        Returns:
-            Returns main.TRUE if it successfully installed
-        """
-        result = main.TRUE
-        threads = []
-        i = 0
-        for ctrl in self.controllers if installMax else self.runningNodes:
-            options = ""
-            if installMax and i >= self.numCtrls:
-                # TODO: is installMax supported here?
-                pass
-            if installParallel:
-                t = main.Thread( target=ctrl.Bench.atomixInstall,
-                                 name="atomix-install-" + ctrl.name,
-                                 kwargs={ "node" : ctrl.ipAddress,
-                                          "options" : options } )
-                threads.append( t )
-                t.start()
-            else:
-                result = result and \
-                            main.ONOSbench.atomixInstall( node=ctrl.ipAddress, options=options )
-            i += 1
-        if installParallel:
-            for t in threads:
-                t.join()
-                result = result and t.result
-        return result
-
-    def installOnos( self, installMax=True, installParallel=True ):
+    def install( self, installMax=True, installParallel=True ):
         """
         Description:
             Installing onos.
@@ -385,7 +306,7 @@
                 options = "-nf"
             if installParallel:
                 t = main.Thread( target=ctrl.Bench.onosInstall,
-                                 name="onos-install-" + ctrl.name,
+                                 name="install-" + ctrl.name,
                                  kwargs={ "node" : ctrl.ipAddress,
                                           "options" : options } )
                 threads.append( t )
diff --git a/TestON/tests/dependencies/ONOSSetup.py b/TestON/tests/dependencies/ONOSSetup.py
index 8879220..66eced1 100644
--- a/TestON/tests/dependencies/ONOSSetup.py
+++ b/TestON/tests/dependencies/ONOSSetup.py
@@ -183,23 +183,6 @@
             # main.scale[ 0 ] determines the current number of ONOS controller
             main.Cluster.setRunningNode( int( main.scale.pop( 0 ) ) )
 
-    def killingAllAtomix( self, cluster, killRemoveMax, stopAtomix ):
-        """
-        Description:
-            killing atomix. It will either kill the current runningnodes or
-            max number of the nodes.
-        Required:
-            * cluster - the cluster driver that will be used.
-            * killRemoveMax - The boolean that will decide either to kill
-            only running nodes ( False ) or max number of nodes ( True ).
-            * stopAtomix - If wish to stop atomix before killing it. True for
-            enable stop, False for disable stop.
-        Returns:
-            Returns main.TRUE if successfully killing it.
-        """
-        main.log.info( "Safety check, killing all Atomix processes" )
-        return cluster.killAtomix( killRemoveMax, stopAtomix )
-
     def killingAllOnos( self, cluster, killRemoveMax, stopOnos ):
         """
         Description:
@@ -210,12 +193,13 @@
             * killRemoveMax - The boolean that will decide either to kill
             only running nodes ( False ) or max number of nodes ( True ).
             * stopOnos - If wish to stop onos before killing it. True for
-            enable stop, False for disable stop.
+            enable stop , False for disable stop.
         Returns:
             Returns main.TRUE if successfully killing it.
         """
         main.log.info( "Safety check, killing all ONOS processes" )
-        return cluster.killOnos( killRemoveMax, stopOnos )
+
+        return cluster.kill( killRemoveMax, stopOnos )
 
     def createApplyCell( self, cluster, newCell, cellName, cellApps,
                          mininetIp, useSSH, ips, installMax=False ):
@@ -245,25 +229,6 @@
                                  onfail="Failed to apply cell to environment" )
         return stepResult
 
-    def uninstallAtomix( self, cluster, uninstallMax ):
-        """
-        Description:
-            uninstalling atomix and verify the result.
-        Required:
-            * cluster - a cluster driver that will be used.
-            * uninstallMax - True for uninstalling max number of nodes
-            False for uninstalling the current running nodes.
-        Returns:
-            Returns main.TRUE if it successfully uninstalled.
-        """
-        main.step( "Uninstalling Atomix" )
-        atomixUninstallResult = cluster.uninstallAtomix( uninstallMax )
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=atomixUninstallResult,
-                                 onpass="Successfully uninstalled Atomix",
-                                 onfail="Failed to uninstall Atomix" )
-        return atomixUninstallResult
-
     def uninstallOnos( self, cluster, uninstallMax ):
         """
         Description:
@@ -276,7 +241,7 @@
             Returns main.TRUE if it successfully uninstalled.
         """
         main.step( "Uninstalling ONOS package" )
-        onosUninstallResult = cluster.uninstallOnos( uninstallMax )
+        onosUninstallResult = cluster.uninstall( uninstallMax )
         utilities.assert_equals( expect=main.TRUE,
                                  actual=onosUninstallResult,
                                  onpass="Successfully uninstalled ONOS package",
@@ -300,29 +265,6 @@
                                  onfail="Failed to create ONOS package" )
         return packageResult
 
-    def installAtomix( self, cluster, installMax, parallel=True ):
-        """
-        Description:
-            Installing atomix and verify the result
-        Required:
-            * cluster - the cluster driver that will be used.
-            * installMax - True for installing max number of nodes
-            False for installing current running nodes only.
-        Returns:
-            Returns main.TRUE if it successfully installed
-        """
-        main.step( "Installing Atomix" )
-        atomixInstallResult = main.TRUE
-
-        cluster.installAtomix( installMax, parallel )
-        utilities.assert_equals( expect=main.TRUE,
-                                 actual=atomixInstallResult,
-                                 onpass="Successfully installed Atomix",
-                                 onfail="Failed to install Atomix" )
-        if not atomixInstallResult:
-            main.cleanAndExit()
-        return atomixInstallResult
-
     def installOnos( self, cluster, installMax, parallel=True ):
         """
         Description:
@@ -337,7 +279,7 @@
         main.step( "Installing ONOS package" )
         onosInstallResult = main.TRUE
 
-        cluster.installOnos( installMax, parallel )
+        cluster.install( installMax, parallel )
         utilities.assert_equals( expect=main.TRUE,
                                  actual=onosInstallResult,
                                  onpass="Successfully installed ONOS package",
@@ -417,8 +359,7 @@
     def ONOSSetUp( self, cluster, hasMultiNodeRounds=False, startOnos=True, newCell=True,
                    cellName="temp", cellApps="drivers", mininetIp="", removeLog=False, extraApply=None, applyArgs=None,
                    extraClean=None, cleanArgs=None, skipPack=False, installMax=False, useSSH=True,
-                   killRemoveMax=True, stopAtomix=False, stopOnos=False, installParallel=True, cellApply=True,
-                   includeCaseDesc=True ):
+                   killRemoveMax=True, stopOnos=False, installParallel=True, cellApply=True, includeCaseDesc=True ):
         """
         Description:
             Initial ONOS setting up of the tests. It will also verify the result of each steps.
@@ -453,7 +394,6 @@
             * useSSH - True for using ssh when creating a cell
             * killRemoveMax - True for removing/killing max number of nodes. False for
             removing/killing running nodes only.
-            * stopAtomix - True if wish to stop atomix before killing it.
             * stopOnos - True if wish to stop onos before killing it.
         Returns:
             Returns main.TRUE if it everything successfully proceeded.
@@ -464,9 +404,7 @@
                        " node(s) ONOS cluster" )
             main.caseExplanation = "Set up ONOS with " + str( cluster.numCtrls ) + \
                                    " node(s) ONOS cluster"
-        atomixKillResult = self.killingAllAtomix( cluster, killRemoveMax, stopAtomix )
-        onosKillResult = self.killingAllOnos( cluster, killRemoveMax, stopOnos )
-        killResult = atomixKillResult and onosKillResult
+        killResult = self.killingAllOnos( cluster, killRemoveMax, stopOnos )
 
         main.log.info( "NODE COUNT = " + str( cluster.numCtrls ) )
         cellResult = main.TRUE
@@ -490,17 +428,13 @@
         if removeLog:
             main.log.info("Removing raft logs")
             main.ONOSbench.onosRemoveRaftLogs()
-        atomixUninstallResult = self.uninstallAtomix( cluster, killRemoveMax )
         onosUninstallResult = self.uninstallOnos( cluster, killRemoveMax )
-        uninstallResult = atomixUninstallResult and onosUninstallResult
         self.processList( extraApply, applyArgs )
 
         if not skipPack:
             packageResult = self.buildOnos(cluster)
 
-        atomixInstallResult = self.installAtomix( cluster, installMax, installParallel )
         onosInstallResult = self.installOnos( cluster, installMax, installParallel )
-        installResult = atomixInstallResult and onosInstallResult
 
         self.processList( extraClean, cleanArgs )
         secureSshResult = self.setupSsh( cluster )
@@ -510,5 +444,5 @@
         if startOnos:
             onosCliResult = self.startOnosClis( cluster )
 
-        return killResult and cellResult and packageResult and uninstallResult and \
-               installResult and secureSshResult and onosServiceResult and onosCliResult
+        return killResult and cellResult and packageResult and onosUninstallResult and \
+               onosInstallResult and secureSshResult and onosServiceResult and onosCliResult