diff --git a/TestON/drivers/common/cli/emulator/mininetclidriver.py b/TestON/drivers/common/cli/emulator/mininetclidriver.py
index 03fc5ca..9c48e32 100644
--- a/TestON/drivers/common/cli/emulator/mininetclidriver.py
+++ b/TestON/drivers/common/cli/emulator/mininetclidriver.py
@@ -163,7 +163,6 @@
             pattern = 'Results\:\s0\%\sdropped\s'
             #FIXME:Pending Mininet Pull Request #408
             #pattern = 'Results\:\s0\.00\%\sdropped\s'
-            print response
             #if utilities.assert_matches(expect=pattern,actual=response,onpass="All hosts are reaching",onfail="Unable to reach all the hosts"):
             if re.search(pattern,response):
                 main.log.info(self.name+": All hosts are reachable")
@@ -799,6 +798,62 @@
             main.cleanup()
             main.exit()
 
+    def compare_switches(self, topo, switches_json):
+        '''
+        Compare mn and onos switches
+        topo: sts TestONTopology object
+        switches_json: parsed json object from the onos devices api
+
+        This uses the sts TestONTopology object
+
+        '''
+        import json
+        results = main.TRUE
+        output = {"switches":[]}
+        for switch in topo.graph.switches: #iterate through the MN topology and pull out switches and and port info
+            #print vars(switch)
+            ports = []
+            for port in switch.ports.values():
+                #print port.hw_addr.toStr(separator = '')
+                ports.append({'of_port': port.port_no, 'mac': str(port.hw_addr).replace('\'',''), 'name': port.name})
+            output['switches'].append({"name": switch.name, "dpid": str(switch.dpid).zfill(16), "ports": ports })
+        #print output
+
+        #print json.dumps(output, sort_keys=True,indent=4,separators=(',', ': '))
+
+
+        # created sorted list of dpid's in MN and ONOS for comparison
+        mnDPIDs=[]
+        for switch in output['switches']:
+            mnDPIDs.append(switch['dpid'])
+        mnDPIDs.sort()
+        #print mnDPIDs
+        if switches_json == "":#if rest call fails
+            main.log.error(self.name + ".compare_topo(): Empty JSON object given from ONOS")
+            return main.FALSE
+        onos=switches_json
+        onosDPIDs=[]
+        for switch in onos:
+            onosDPIDs.append(switch['id'].replace(":",'').replace("of",''))
+            #print switch
+        onosDPIDs.sort()
+        #print onosDPIDs
+
+        if mnDPIDs!=onosDPIDs:
+            switch_results = main.FALSE
+            main.log.report( "Switches in MN but not in ONOS:")
+            main.log.report( str([switch for switch in mnDPIDs if switch not in onosDPIDs]))
+            main.log.report( "Switches in ONOS but not in MN:")
+            main.log.report(  str([switch for switch in onosDPIDs if switch not in mnDPIDs]))
+        else:#list of dpid's match in onos and mn
+            #main.log.report("DEBUG: The dpid's of the switches in Mininet and ONOS match")
+            switch_results = main.TRUE
+        return switch_results
+
+
+
+
+
     def compare_topo(self, topo, onos_json):
         '''
         compares mn topology with ONOS topology
diff --git a/TestON/drivers/common/cli/onosclidriver.py b/TestON/drivers/common/cli/onosclidriver.py
index 593927b..3318f71 100644
--- a/TestON/drivers/common/cli/onosclidriver.py
+++ b/TestON/drivers/common/cli/onosclidriver.py
@@ -426,16 +426,25 @@
             else:
                 if not grep_str:
                     self.handle.sendline("devices")
-                    self.handle.expect("devices")
+                    self.handle.expect("onos>")
+                    self.handle.sendline("")
                     self.handle.expect("onos>")
                 else:
                     self.handle.sendline("devices | grep '"+
                         str(grep_str)+"'")
-                    self.handle.expect("devices | grep '"+str(grep_str)+"'")
                     self.handle.expect("onos>")
+                    self.handle.sendline("")
+                    self.handle.expect("onos>")
+<<<<<<< HEAD
                     handle = self.handle.before
                     print "handle =",handle
                     return handle
+=======
+           
+            handle = self.handle.before
+            
+            return handle
+>>>>>>> d1192e144d179c68864828aa6a339764d69d1216
         except pexpect.EOF:
             main.log.error(self.name + ": EOF exception found")
             main.log.error(self.name + ":    " + self.handle.before)
@@ -448,7 +457,6 @@
             main.cleanup()
             main.exit()
 
-
     def links(self, json_format=True, grep_str=""):
         '''
         Lists all core links
@@ -478,17 +486,25 @@
             else:
                 if not grep_str:
                     self.handle.sendline("links")
-                    self.handle.expect("links")
+                    self.handle.expect("onos>")
+                    self.handle.sendline("")
                     self.handle.expect("onos>")
                 else:
                     self.handle.sendline("links | grep '"+
                         str(grep_str)+"'")
-                    self.handle.expect("links | grep '"+str(grep_str)+"'")
+                    self.handle.expect("onos>")
+                    self.handle.sendline("")
                     self.handle.expect("onos>")
            
+<<<<<<< HEAD
                 handle = self.handle.before
                 print "handle =",handle
                 return handle
+=======
+            handle = self.handle.before
+            
+            return handle
+>>>>>>> d1192e144d179c68864828aa6a339764d69d1216
         except pexpect.EOF:
             main.log.error(self.name + ": EOF exception found")
             main.log.error(self.name + ":    " + self.handle.before)
@@ -531,16 +547,25 @@
             else:
                 if not grep_str:
                     self.handle.sendline("ports")
-                    self.handle.expect("ports")
+                    self.handle.expect("onos>")
+                    self.handle.sendline("")
                     self.handle.expect("onos>")
                 else:
                     self.handle.sendline("ports | grep '"+
                         str(grep_str)+"'")
-                    self.handle.expect("ports | grep '"+str(grep_str)+"'")
                     self.handle.expect("onos>")
+                    self.handle.sendline("")
+                    self.handle.expect("onos>")
+<<<<<<< HEAD
                 handle = self.handle.before
                 print "handle =",handle
                 return handle
+=======
+           
+            handle = self.handle.before
+            
+            return handle
+>>>>>>> d1192e144d179c68864828aa6a339764d69d1216
         except pexpect.EOF:
             main.log.error(self.name + ": EOF exception found")
             main.log.error(self.name + ":    " + self.handle.before)
@@ -688,6 +713,157 @@
             main.cleanup()
             main.exit()
 
+    def add_host_intent(self, host_id_one, host_id_two):
+        '''
+        Required:
+            * host_id_one: ONOS host id for host1
+            * host_id_two: ONOS host id for host2
+        Description:
+            Adds a host-to-host intent (bidrectional) by
+            specifying the two hosts. 
+        '''
+        try:
+            self.handle.sendline("")
+            self.handle.expect("onos>")
+            
+            self.handle.sendline("add-host-intent "+
+                    str(host_id_one) + " " + str(host_id_two))
+            self.handle.expect("onos>")
+
+            self.handle.sendline("")
+            self.handle.expect("onos>")
+
+            handle = self.handle.before
+
+            main.log.info("Intent installed between "+
+                    str(host_id_one) + " and " + str(host_id_two))
+
+            return handle
+        
+        except pexpect.EOF:
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":    " + self.handle.before)
+            main.cleanup()
+            main.exit()
+        except:
+            main.log.info(self.name+" ::::::")
+            main.log.error( traceback.print_exc())
+            main.log.info(self.name+" ::::::")
+            main.cleanup()
+            main.exit()
+
+    def add_point_intent(self, ingress_device, port_ingress,
+            egress_device, port_egress):
+        '''
+        Required:
+            * ingress_device: device id of ingress device
+            * egress_device: device id of egress device
+        Description:
+            Adds a point-to-point intent (uni-directional) by
+            specifying device id's 
+        
+        NOTE: This function may change depending on the 
+              options developers provide for point-to-point
+              intent via cli
+        '''
+        try:
+            self.handle.sendline("")
+            self.handle.expect("onos>")
+
+            self.handle.sendline("add-point-intent "+
+                    str(ingress_device) + "/" + str(port_ingress) + " " +
+                    str(egress_device) + "/" + str(port_egress))
+            i = self.handle.expect([
+                "Error",
+                "onos>"])
+            
+            self.handle.sendline("")
+            self.handle.expect("onos>")
+
+            handle = self.handle.before
+
+            if i == 0:
+                main.log.error("Error in adding point-to-point intent")
+                return handle
+            else:
+                return main.TRUE
+        
+        except pexpect.EOF:
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":    " + self.handle.before)
+            main.cleanup()
+            main.exit()
+        except:
+            main.log.info(self.name+" ::::::")
+            main.log.error( traceback.print_exc())
+            main.log.info(self.name+" ::::::")
+            main.cleanup()
+            main.exit()
+
+    def remove_intent(self, intent_id):
+        '''
+        Remove intent for specified intent id
+        '''
+        try:
+            self.handle.sendline("")
+            self.handle.expect("onos>")
+
+            self.handle.sendline("remove-intent "+str(intent_id))
+            i = self.handle.expect([
+                "Error",
+                "onos>"])
+           
+            handle = self.handle.before
+
+            if i == 0:
+                main.log.error("Error in removing intent")
+                return handle
+            else:
+                return handle 
+        
+        except pexpect.EOF:
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":    " + self.handle.before)
+            main.cleanup()
+            main.exit()
+        except:
+            main.log.info(self.name+" ::::::")
+            main.log.error( traceback.print_exc())
+            main.log.info(self.name+" ::::::")
+            main.cleanup()
+            main.exit()
+
+    def intents(self):
+        '''
+        Description:
+            Obtain intents currently installed 
+        '''
+        try:
+            self.handle.sendline("")
+            self.handle.expect("onos>")
+
+            self.handle.sendline("intents")
+            self.handle.expect("onos>")
+
+            self.handle.sendline("")
+            self.handle.expect("onos>")
+
+            handle = self.handle.before
+
+            return handle
+
+        except pexpect.EOF:
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":    " + self.handle.before)
+            main.cleanup()
+            main.exit()
+        except:
+            main.log.info(self.name+" ::::::")
+            main.log.error( traceback.print_exc())
+            main.log.info(self.name+" ::::::")
+            main.cleanup()
+            main.exit()
+
     #Wrapper functions ****************
     #Wrapper functions use existing driver
     #functions and extends their use case.
@@ -695,6 +871,50 @@
     #a normal driver function, and parse it
     #using a wrapper function
 
+    def get_all_intents_id(self):
+        '''
+        Description:
+            Obtain all intent id's in a list
+        '''
+        try:
+            #Obtain output of intents function
+            intents_str = self.intents()
+            all_intent_list = []
+            intent_id_list = []
+
+            #Parse the intents output for ID's
+            intents_list = [s.strip() for s in intents_str.splitlines()]
+            for intents in intents_list:
+                if "onos>" in intents:
+                    continue
+                elif "intents" in intents:
+                    continue
+                else:
+                    line_list = intents.split(" ")
+                    all_intent_list.append(line_list[0])
+            
+            all_intent_list = all_intent_list[1:-2]
+
+            for intents in all_intent_list:
+                if not intents:
+                    continue
+                else:
+                    intent_id_list.append(intents) 
+
+            return intent_id_list
+
+        except pexpect.EOF:
+            main.log.error(self.name + ": EOF exception found")
+            main.log.error(self.name + ":    " + self.handle.before)
+            main.cleanup()
+            main.exit()
+        except:
+            main.log.info(self.name+" ::::::")
+            main.log.error( traceback.print_exc())
+            main.log.info(self.name+" ::::::")
+            main.cleanup()
+            main.exit()
+
     def get_all_devices_id(self):
         '''
         Use 'devices' function to obtain list of all devices
@@ -710,7 +930,7 @@
         '''
         try:
             #Call devices and store result string
-            devices_str = self.devices()
+            devices_str = self.devices(json_format=False)
             id_list = []
             
             if not devices_str:
diff --git a/TestON/tests/ONOSNextTest/ONOSNextTest.py b/TestON/tests/ONOSNextTest/ONOSNextTest.py
index 0e7a707..f01446c 100755
--- a/TestON/tests/ONOSNextTest/ONOSNextTest.py
+++ b/TestON/tests/ONOSNextTest/ONOSNextTest.py
@@ -22,7 +22,8 @@
         onos-install -f
         onos-wait-for-start
         '''
-        
+        import time
+
         cell_name = main.params['ENV']['cellName']
         ONOS1_ip = main.params['CTRL']['ip1']
         ONOS1_port = main.params['CTRL']['port1']
@@ -33,20 +34,21 @@
         #params: (bench ip, cell name, mininet ip, *onos ips)
         cell_file_result = main.ONOSbench.create_cell_file(
                 "10.128.20.10", "temp_cell_2", "10.128.10.90",
-                "10.128.10.11", "10.128.10.12", "10.128.10.13")
+                "onos-core-trivial,onos-app-fwd",
+                "10.128.20.11")
 
         main.step("Applying cell variable to environment")
         cell_result = main.ONOSbench.set_cell(cell_name)
+        #cell_result = main.ONOSbench.set_cell("temp_cell_2")
         verify_result = main.ONOSbench.verify_cell()
         
         main.step("Git checkout and pull master")
-        main.ONOSbench.git_checkout("master")
-        git_pull_result = main.ONOSbench.git_pull()
-
-
+        #main.ONOSbench.git_checkout("master")
+        #git_pull_result = main.ONOSbench.git_pull()
+        
         main.step("Using mvn clean & install")
-        clean_install_result = main.ONOSbench.clean_install()
-        #clean_install_result = main.TRUE
+        #clean_install_result = main.ONOSbench.clean_install()
+        clean_install_result = main.TRUE
 
         main.step("Creating ONOS package")
         package_result = main.ONOSbench.onos_package()
@@ -65,6 +67,8 @@
                 onpass="Test startup successful",
                 onfail="Test startup NOT successful")
 
+        time.sleep(10)
+
     def CASE11(self, main):
         '''
         Cleanup sequence:
@@ -160,7 +164,8 @@
         ONOS cli driver functions can be used for.
         '''
         import time
-        
+        import json
+
         cell_name = main.params['ENV']['cellName']
         ONOS1_ip = main.params['CTRL']['ip1']
         
@@ -176,8 +181,8 @@
         topology_obj = main.ONOScli.topology()
 
         main.step("issue various feature:install <str> commands")
-        main.ONOScli.feature_install("onos-app-fwd")
-        main.ONOScli.feature_install("onos-rest")
+        #main.ONOScli.feature_install("onos-app-fwd")
+        #main.ONOScli.feature_install("onos-rest")
 
         main.step("Add a bad node")
         node_result = main.ONOScli.add_node("111", "10.128.20.")
@@ -194,7 +199,7 @@
             main.Mininet2.handle.expect("mininet>")
         #Need to sleep to allow switch add processing
         time.sleep(5)
-        list_result = main.ONOScli.devices()
+        list_result = main.ONOScli.devices(json_format=False)
         main.log.info(list_result)
 
         main.step("Get all devices id")
@@ -220,9 +225,87 @@
         if device_role_result == main.TRUE:
             main.log.report("Device role successfully set")
 
+        main.step("Revert device role to master")
+        device_role = main.ONOScli.device_role(
+                devices_id_list[0], node_id_list[0], "master")
+
         main.step("Check devices / role again")
-        dev_result = main.ONOScli.devices()
+        dev_result = main.ONOScli.devices(json_format=False)
         main.log.info(dev_result)
+       
+        #Sample steps to push intents ***********
+        # * Obtain host id in ONOS format 
+        # * Push intents
+        main.step("Get list of hosts from Mininet")
+        host_list = main.Mininet2.get_hosts()
+        main.log.info(host_list)
+
+        main.step("Get host list in ONOS format")
+        host_onos_list = main.ONOScli.get_hosts_id(host_list)
+        main.log.info(host_onos_list)
+
+        time.sleep(5)
+
+        #We must use ping from hosts we want to add intents from 
+        #to make the hosts talk
+        #main.Mininet2.handle.sendline("\r")
+        #main.Mininet2.handle.sendline("h4 ping 10.1.1.1 -c 1 -W 1")
+        #time.sleep(3)
+        #main.Mininet2.handle.sendline("h5 ping 10.1.1.1 -c 1 -W 1")
+        #time.sleep(5)
+
+        main.ONOScli.feature_install("onos-app-fwd")
+        
+        main.Mininet2.pingall()
+
+        time.sleep(5)
+
+        main.step("Get hosts")
+        main.ONOScli.handle.sendline("hosts")
+        main.ONOScli.handle.expect("onos>")
+        hosts = main.ONOScli.handle.before
+        main.log.info(hosts)
+
+        main.step("Install host-to-host-intents")
+        intent_install1 = main.ONOScli.add_host_intent(
+                host_onos_list[0], host_onos_list[1])
+        intent_install2 = main.ONOScli.add_host_intent(
+                host_onos_list[2], host_onos_list[3])
+        intent_install3 = main.ONOScli.add_host_intent(
+                host_onos_list[4], host_onos_list[5])
+
+        main.log.info(intent_install1)
+        main.log.info(intent_install2)
+        main.log.info(intent_install3)
+
+        main.step("Get intents installed on ONOS")
+        get_intent_result = main.ONOScli.intents()
+        main.log.info(get_intent_result)
+        #****************************************
+
+        #Sample steps to delete intents ********
+        main.step("Get all intent id's")
+        intent_id = main.ONOScli.get_all_intents_id()
+        main.log.info(intent_id)
+
+        main.step("Remove specified intent id: "+str(intent_id[0]))
+        intent_result = main.ONOScli.remove_intent(intent_id[0])
+        main.log.info(intent_result)
+
+        main.step("Check installed intents again")
+        get_intent_result = main.ONOScli.intents()
+        main.log.info(get_intent_result)
+        #***************************************
+
+        #Sample steps to add point-to-point intents*
+        main.step("Add point-to-point intents")
+        ptp_intent_result = main.ONOScli.add_point_intent(
+                devices_id_list[0], 1, devices_id_list[1], 2)
+        if ptp_intent_result == main.TRUE:
+            get_intent_result = main.ONOScli.intents()
+            main.log.info("Point to point intent install successful")
+            main.log.info(get_intent_result)
+        #*******************************************
 
 ######
 #jhall@onlab.us
diff --git a/TestON/tests/ONOSNextTest/ONOSNextTest.topo b/TestON/tests/ONOSNextTest/ONOSNextTest.topo
index a5f544a..118e57c 100755
--- a/TestON/tests/ONOSNextTest/ONOSNextTest.topo
+++ b/TestON/tests/ONOSNextTest/ONOSNextTest.topo
@@ -22,7 +22,7 @@
         <ONOS1>
             <host>10.128.20.11</host>
             <user>sdn</user>
-            <password>sdn</password>
+            <password>rocks</password>
             <type>OnosDriver</type>
             <connect_order>3</connect_order>
             <COMPONENTS> </COMPONENTS>
diff --git a/TestON/tests/TopoPerfNext/TopoPerfNext.params b/TestON/tests/TopoPerfNext/TopoPerfNext.params
index 25ae644..d8d8b37 100644
--- a/TestON/tests/TopoPerfNext/TopoPerfNext.params
+++ b/TestON/tests/TopoPerfNext/TopoPerfNext.params
@@ -12,6 +12,7 @@
     </GIT>
 
     <CTRL>
+        <user>sdn</user>
         <ip1>10.128.20.11</ip1>
         <port1>6633</port1>
         <ip2>10.128.20.12</ip2>
diff --git a/TestON/tests/TopoPerfNext/TopoPerfNext.py b/TestON/tests/TopoPerfNext/TopoPerfNext.py
index ce71272..2fe521b 100644
--- a/TestON/tests/TopoPerfNext/TopoPerfNext.py
+++ b/TestON/tests/TopoPerfNext/TopoPerfNext.py
@@ -32,7 +32,7 @@
 
         main.step("Creating cell file")
         cell_file_result = main.ONOSbench.create_cell_file(
-                BENCH_ip, cell_name, MN1_ip,
+                BENCH_ip, cell_name, MN1_ip, "onos-core",
                 ONOS1_ip, ONOS2_ip, ONOS3_ip)
 
         main.step("Applying cell file to environment")
@@ -74,10 +74,16 @@
         Assign s1 to ONOS1 and measure latency
         '''
         import time
+        import subprocess
+        import json
+        import requests
+        import os
 
         ONOS1_ip = main.params['CTRL']['ip1']
         ONOS2_ip = main.params['CTRL']['ip2']
         ONOS3_ip = main.params['CTRL']['ip3']
+        ONOS_user = main.params['CTRL']['user']
+
         default_sw_port = main.params['CTRL']['port1']
        
         #Number of iterations of case
@@ -90,7 +96,10 @@
         #String to grep in tshark output
         tshark_tcp_string = "TCP 74 "+default_sw_port
         tshark_of_string = "OFP 86 Vendor"
-       
+     
+        #Initialize assertion to TRUE
+        assertion = main.TRUE
+        
         main.log.report("Latency of adding one switch")
 
         for i in range(0, int(num_iter)):
@@ -122,14 +131,83 @@
     
             main.ONOS1.stop_tshark()
 
+            #tshark output is saved in ONOS. Use subprocess
+            #to copy over files to TestON for parsing
+            main.log.info("Copying over tshark files")
+            
+            #TCP CAPTURE ****
+            ssh_tcp_file = subprocess.Popen(['ssh',
+                ONOS_user+"@"+ONOS1_ip, 'cat', 
+                tshark_tcp_output], stdout=subprocess.PIPE)
+            temp_text = ssh_tcp_file.stdout.readline()
+            temp_text = temp_text.split(" ")
 
+            main.log.info("Object read in from TCP capture: "+
+                    str(temp_text))
+            if len(temp_text) > 0:
+                t0_tcp = int(float(temp_text[1])*1000)
+            else:
+                main.log.error("Tshark output file for TCP"+
+                        " returned unexpected results")
+                t0_tcp = 0
+                assertion = main.FALSE
+            #****************
 
+            #OF CAPTURE ****
+            ssh_of_file = subprocess.Popen(['ssh',
+                ONOS_user+"@"+ONOS1_ip, 'cat',
+                tshark_of_output], stdout=subprocess.PIPE)
 
+            while True:
+                temp_text = ssh_of_file.stdout.readline()
+                if line !='':
+                    line_ofp = temp_text
+                else:
+                    break 
+            obj = line_ofp.split(" ")
+            
+            main.log.info("Object read in from OFP capture: "+
+                    str(line_ofp))
+    
+            if len(line_ofp) > 0:
+                t0_ofp = int(float(obj[1])*1000)
+            else:
+                main.log.error("Tshark output file for OFP"+
+                        " returned unexpected results")
+                t0_ofp = 0
+                assertion = main.FALSE
+            #****************
+           
+            #TODO: 
+            #Get json object from all 3 ONOS instances
+            
+            #TODO:
+            #Parse json object for timestamp
+            topo_timestamp_1 = 0
+            topo_timestamp_2 = 0
+            topo_timestamp_3 = 0
 
+            #ONOS processing latency
+            delta_of_1 = int(topo_timestamp_1) - int(t0_ofp)
+            delta_of_2 = int(topo_timestamp_2) - int(t0_ofp)
+            delta_of_3 = int(topo_timestamp_3) - int(t0_ofp)
+    
+            #End-to-end processing latency
+            delta_tcp_1 = int(topo_timestamp_1) - int(t0_tcp)
+            delta_tcp_2 = int(topo_timestamp_2) - int(t0_tcp)
+            delta_tcp_3 = int(topo_timestamp_3) - int(t0_tcp)
 
+            #TODO:
+            #Fetch logs upon threshold excess
 
+            main.log.info("ONOS1 delta OFP: "+str(delta_of_1))
+            main.log.info("ONOS2 delta OFP: "+str(delta_of_2))
+            main.log.info("ONOS3 delta OFP: "+str(delta_of_3))
 
-
+            main.log.info("ONOS1 delta TCP: "+str(delta_tcp_1))
+            main.log.info("ONOS2 delta TCP: "+str(delta_tcp_2))
+            main.log.info("ONOS3 delta TCP: "+str(delta_tcp_3))
+