diff --git a/TestON/drivers/common/cli/emulator/mininetclidriver.py b/TestON/drivers/common/cli/emulator/mininetclidriver.py
index 09ac89c..76a8fa7 100644
--- a/TestON/drivers/common/cli/emulator/mininetclidriver.py
+++ b/TestON/drivers/common/cli/emulator/mininetclidriver.py
@@ -193,11 +193,6 @@
         if self.handle :
             try:
                 response = self.execute(cmd=host+" ifconfig",prompt="mininet>",timeout=10)
-                print("response 2"+ response)
-                self.handle.sendline(host+" ifconfig")
-                self.handle.expect(["mininet>",pexpect.TIMEOUT])
-                response = self.handle.before + self.handle.after
-                print(response)
             except pexpect.EOF:  
                 main.log.error(self.name + ": EOF exception found")
                 main.log.error(self.name + ":     " + self.handle.before)
@@ -540,6 +535,7 @@
             response = self.execute(cmd=command,prompt="mininet>",timeout=10)
             print(response)
             if response:
+                print("**********************")
                 return response
             else:
                 return main.FALSE
diff --git a/TestON/drivers/common/cli/onosclidriver.py b/TestON/drivers/common/cli/onosclidriver.py
index 4b412eb..41f1951 100644
--- a/TestON/drivers/common/cli/onosclidriver.py
+++ b/TestON/drivers/common/cli/onosclidriver.py
@@ -431,7 +431,148 @@
             main.exit()
 
 
-    def add_intent(self, intent_id,src_dpid,dst_dpid,src_mac,dst_mac,intentIP,intentPort=8080,intentURL="wm/onos/intent/high" , intent_type = 'SHORTEST_PATH', static_path=False, src_port=1,dst_port=1):
+
+#*********************************************************************
+#*********************************************************************
+# shortest_path is a command to find the shortest path between two 
+# switches. It is called using the IP, port, and source and 
+# destination dpids
+#*********************************************************************
+#*********************************************************************
+
+    def shortest_path(self,ONOSIP,ONOSPort,srcDPID,dstDPID):
+        main.log.report("Finding the shortest Path between "+str(srcDPID) + " to " + str(dstDPID))
+        url = "http://%s:%s/wm/onos/intent/path/switch/%s/shortest-path/%s"%(ONOSIP,ONOSPort,srcDPID,dstDPID)
+        parsed_result = []
+        try: 
+            response = urllib2.urlopen(url)
+            result = response.read()
+            response.close()
+            if len(result) != 0:
+                parsed_result = json.loads(result)
+        except HTTPError as exc: 
+            print "ERROR:"
+            print "  REST GET URL: %s" % url
+            # NOTE: exc.fp contains the object with the response payload
+            error_payload = json.loads(exc.fp.read())
+            print "  REST Error Code: %s" % (error_payload['code'])
+            print "  REST Error Summary: %s" % (error_payload['summary'])
+            print "  REST Error Description: %s" % (error_payload['formattedDescription'])
+            print "  HTTP Error Code: %s" % exc.code
+            print "  HTTP Error Reason: %s" % exc.reason
+        except URLError as exc: 
+            print "ERROR:"
+            print "  REST GET URL: %s" % url
+            print "  URL Error Reason: %s" % exc.reason
+     
+        if len(parsed_result)==0:
+            return
+        result = json.dumps(parsed_result,indent=4)
+        print(str(result))
+        return result
+
+
+#*********************************************************************
+#*********************************************************************
+# show_intent is a command to show intents. 
+# Parameters include intentIP, intentPort, intentURL, and intent_id
+# Based on the url, it will show either high or low intents
+# If intent_id is left blank, it will show all high or all low intents
+# Else it will show the intent with the id
+#*********************************************************************
+#*********************************************************************
+
+
+
+    def show_intent(self,intentIP,intentPort=8080,intentURL="wm/onos/intent",intent_type="high",intent_id="all"):
+        main.log.report("Getting (an) intent(s)")
+        if intent_id=="all":
+            url = "http://%s:%s/%s/%s"%(intentIP,intentPort,intentURL,intent_type)
+        else:
+            url = "http://%s:%s/%s/%s/%s"%(intentIP,intentPort,intentURL,intent_type,intent_id)
+        print(url)
+        parsed_result = []
+        try:
+            response = urllib2.urlopen(url)
+            result = response.read()
+            response.close()
+            if len(result) != 0:
+                parsed_result = json.loads(result)
+        except HTTPError as exc:
+            print "ERROR:"
+            print "  REST GET URL: %s" % url
+            # NOTE: exc.fp contains the object with the response payload
+            error_payload = json.loads(exc.fp.read())
+            print "  REST Error Code: %s" % (error_payload['code'])
+            print "  REST Error Summary: %s" % (error_payload['summary'])
+            print "  REST Error Description: %s" % (error_payload['formattedDescription'])
+            print "  HTTP Error Code: %s" % exc.code
+            print "  HTTP Error Reason: %s" % exc.reason
+            return str(error_payload['code'])
+        except URLError as exc:
+            print "ERROR:"
+            print "  REST GET URL: %s" % url
+            print "  URL Error Reason: %s" % exc.reason
+            return str(error_payload['code'])
+        
+        if len(parsed_result)==0:
+            return
+        result = json.dumps(parsed_result,indent=4)
+        print(str(result))
+        return result
+
+
+#*********************************************************************
+#*********************************************************************
+# del_intent is to delete either all or some or one intents
+# if intent_id is left blank, it will delete all intents
+# else, intent_id should be of  the form "intent_id=1,2,3"
+#*********************************************************************
+#*********************************************************************
+
+    def del_intent(self,intentIP,intentPort=8080,intentURL="wm/onos/intent",intent_id="all"):
+        main.log.report("Deleting (an) intent(s)")
+        if intent_id=="all":
+            url = "http://%s:%s/%s/high"%(intentIP,intentPort,intentURL)
+        else:
+            url = "http://%s:%s/%s/high?%s"%(intentIP,intentPort,intentURL,intent_id)
+
+        print(url)
+
+        parsed_result = []
+        try:
+            request = urllib2.Request(url)
+            request.get_method = lambda: 'DELETE'
+            response = urllib2.urlopen(request)
+            result = response.read()
+            response.close()
+            if len(result) != 0:
+                parsed_result = json.loads(result)
+                print(parsed_result)
+        except HTTPError as exc:
+            print "ERROR:"
+            print "  REST DELETE URL: %s" % url
+            # NOTE: exc.fp contains the object with the response payload
+            error_payload = json.loads(exc.fp.read())
+            print "  REST Error Code: %s" % (error_payload['code'])
+            print "  REST Error Summary: %s" % (error_payload['summary'])
+            print "  REST Error Description: %s" % (error_payload['formattedDescription'])
+            print "  HTTP Error Code: %s" % exc.code
+            print "  HTTP Error Reason: %s" % exc.reason
+        except URLError as exc:
+            print "ERROR:"
+            print "  REST DELETE URL: %s" % url
+            print "  URL Error Reason: %s" % exc.reason
+        return result
+
+#*********************************************************************
+#*********************************************************************
+# add_intent will add a single intent by using dpids and macs. 
+#*********************************************************************
+#*********************************************************************
+
+
+    def add_intent(self, intent_id,src_dpid,dst_dpid,src_mac,dst_mac,intentIP,intentPort=8080,intentURL="wm/onos/intent" , intent_type = 'SHORTEST_PATH', static_path=False, src_port=1,dst_port=1):
         "CLI command callback: set intent"
 
         intents = []
@@ -447,7 +588,7 @@
         oper['matchSrcMac'] = src_mac
         oper['matchDstMac'] = dst_mac
         intents.append(oper)
-        url = "http://%s:%s/%s"%(intentIP,intentPort,intentURL)
+        url = "http://%s:%s/%s/high"%(intentIP,intentPort,intentURL)
         parsed_result = []
         data_json = json.dumps(intents)
         try:
@@ -472,7 +613,7 @@
             print "ERROR:"
             print "  REST GET URL: %s" % url
             print "  URL Error Reason: %s" % exc.reason
-        return parsed_result
+        return result
 
         
 
diff --git a/TestON/tests/JamesTest/JamesTest.params b/TestON/tests/JamesTest/JamesTest.params
index 8cd0cbe..f9540c3 100644
--- a/TestON/tests/JamesTest/JamesTest.params
+++ b/TestON/tests/JamesTest/JamesTest.params
@@ -1,12 +1,17 @@
 <PARAMS>
-    <testcases>1,2,21,31,3,4,5,6,7</testcases>
-    <FLOWDEF>~/flowdef_files/Center_Triangle/flowdef_20.txt</FLOWDEF>
+    <testcases>101,66,10</testcases>
+    <tcpdump> 
+        <intf>eth0</intf>
+        <port>port 6633</port>
+        <filename>~/packet_captures/Sanity.pcap</filename>
+    </tcpdump>
     <CASE1>       
         <destination>h6</destination>
+        <target>h40</target>
     </CASE1>       
     <PING>
-        <source1>h6</source1>
-        <target1>h31</target1>
+        <source1>h7</source1>
+        <target1>h32</target1>
         <source2>h8</source2>
         <target2>h33</target2>
     </PING>
@@ -37,13 +42,21 @@
         <ip4>10.128.4.154</ip4>
         <port4>6633</port4>
     </CTRL>
+    <INTENTREST>
+        <intentIP>10.128.4.151</intentIP>
+        <intentPort>8080</intentPort>
+        <intentURL>wm/onos/intent</intentURL>
+    </INTENTREST>
     <RestIP>10.128.4.151</RestIP>
+    <RestIP2>10.128.4.152</RestIP2>
+    <RestIP3>10.128.4.153</RestIP3>
+    <RestIP4>10.128.4.154</RestIP4>
     <NR_Switches>25</NR_Switches>
     <NR_Links>50</NR_Links>
     <RESTCALL>
 	<restIP1>10.128.4.151</restIP1>
 	<restIP2>10.128.4.152</restIP2>
 	<restPort>8080</restPort>
-	<restURL>/wm/onos/topology/switches</restURL>
+	<restURL>/wm/onos/topology/hosts</restURL>
     </RESTCALL>
 </PARAMS>      
diff --git a/TestON/tests/JamesTest/JamesTest.py b/TestON/tests/JamesTest/JamesTest.py
index 5ba94ec..72f4a44 100644
--- a/TestON/tests/JamesTest/JamesTest.py
+++ b/TestON/tests/JamesTest/JamesTest.py
@@ -1,539 +1,994 @@
 
-
 class JamesTest :
 
+
+
     def __init__(self) :
         self.default = ''
 
-
-
-
-#***************************************************************************************************************
-
-
-    def CASE1(self,main) : 
-        main.case("\nStart-Up of Zookeeper, RAMCloud, ONOS, and Mininet")
-        import time 
-        main.step("\n**********************Git pulls and Rebuilds******************")
+#        def print_hello_world(self,main):
+#            print("hello world")
+#*****************************************************************************************************************************************************************************************
+#Test startup
+#Tests the startup of Zookeeper1, RamCloud1, and ONOS1 to be certain that all started up successfully
+    def CASE1(self,main) :  #Check to be sure ZK, Cass, and ONOS are up, then get ONOS version
+        main.case("Initial setup")
+        main.step("Stop ONOS")
+        import time
+        main.ONOS1.stop_all()
+        main.ONOS2.stop_all()
+        main.ONOS3.stop_all()
+#        main.print_hello_world()
+        main.ONOS4.stop_all()
+        main.ONOS2.stop_rest()
+        main.ONOS1.handle.sendline("cp ~/onos.properties.proactive ~/ONOS/conf/onos.properties")
+        main.ONOS2.handle.sendline("cp ~/onos.properties.proactive ~/ONOS/conf/onos.properties")
+        main.ONOS3.handle.sendline("cp ~/onos.properties.proactive ~/ONOS/conf/onos.properties")
+        main.ONOS4.handle.sendline("cp ~/onos.properties.proactive ~/ONOS/conf/onos.properties")        
+        main.step("Start tcpdump on mn")
+#        main.Mininet2.start_tcpdump(main.params['tcpdump']['filename'], intf = main.params['tcpdump']['intf'], port = main.params['tcpdump']['port'])
+        main.step("Start ONOS")
+        main.Zookeeper1.start()
+        main.Zookeeper2.start()
+        main.Zookeeper3.start()
+        main.Zookeeper4.start()
+        time.sleep(1)
+        main.RamCloud1.del_db()
+        main.RamCloud2.del_db()
+        main.RamCloud3.del_db()
+        main.RamCloud4.del_db()
+        main.log.report("Pulling latest code from github to all nodes")
         for i in range(2):
-            main.log.report("ONOS1 Git Pull")
             uptodate = main.ONOS1.git_pull()
-            ver1 = main.ONOS1.get_version()
-            main.log.report("ONOS2 Git Pull")
             main.ONOS2.git_pull()
-            main.log.report("ONOS3 Git Pull")
             main.ONOS3.git_pull()
-            main.log.report("ONOS4 Git Pull")
             main.ONOS4.git_pull()
+            ver1 = main.ONOS1.get_version()
             ver2 = main.ONOS4.get_version()
             if ver1==ver2:
                 break
             elif i==1:
-                main.log.report("Versions differ. Doing Git pulls from ONOS1")
                 main.ONOS2.git_pull("ONOS1 master")
                 main.ONOS3.git_pull("ONOS1 master")
                 main.ONOS4.git_pull("ONOS1 master")
         if uptodate==0:
-            for i in range(2):
-                main.log.report("Building ONOS1")
-                build1 = main.ONOS1.git_compile()
-                if build1:
-                    break
-                elif i==1:
-                    main.cleanup()
-                    main.exit()
-            for i in range(2):
-                main.log.report("Building ONOS2")
-                build2 = main.ONOS2.git_compile()
-                if build2:
-                    break
-                elif i==1:
-                    main.cleanup()
-                    main.exit()
-            for i in range(2):
-                main.log.report("Building ONOS3")
-                build3 = main.ONOS3.git_compile()
-                if build3:
-                    break
-                elif i==1:
-                    main.cleanup()
-                    main.exit()
-            for i in range(2):
-                main.log.report("Building ONOS4")
-                build4 = main.ONOS4.git_compile()
-                if build4:
-                    break
-                elif i==1:
-                    main.cleanup()
-                    main.exit()
-        
+       # if 1:
+            main.ONOS1.git_compile()
+            main.ONOS2.git_compile()
+            main.ONOS3.git_compile()
+            main.ONOS4.git_compile()
+        main.ONOS1.print_version()    
+        main.ONOS1.start_all()
+        main.ONOS2.start_all()
+        main.ONOS3.start_all()
+        main.ONOS4.start_all()
+        main.ONOS2.start_rest()
+        test= main.ONOS2.rest_status()
+        if test == main.FALSE:
+            main.ONOS1.start_rest()
+        main.ONOS1.get_version()
+        main.log.report("Startup check Zookeeper1, RamCloud1, and ONOS1 connections")
+        main.step("Testing startup Zookeeper")   
+        data =  main.Zookeeper1.isup()
+        utilities.assert_equals(expect=main.TRUE,actual=data,onpass="Zookeeper is up!",onfail="Zookeeper is down...")
+        main.step("Testing startup RamCloud")   
+        data =  main.RamCloud1.status_serv() and main.RamCloud2.status_serv() and main.RamCloud3.status_serv() and main.RamCloud4.status_serv()
+        if data == main.FALSE:
+            main.RamCloud1.stop_coor()
+            main.RamCloud1.stop_serv()
+            main.RamCloud2.stop_serv()
+            main.RamCloud3.stop_serv()
+            main.RamCloud4.stop_serv()
 
-        main.step("\n********************Testing Zookeeper Startup**************")
-        data1 = main.Zookeeper1.isup()
-        utilities.assert_equals(expect=main.TRUE,actual=data1,onpass="Zookeeper is up!",onfail="Zookeeper is down...")
-        if data1==main.FALSE:
-            main.log.report("Zookeeper is Down, Exiting the Test!")
-            main.cleanup()
-            main.exit()
+            time.sleep(5)
+            main.RamCloud1.start_coor()
+            main.RamCloud1.start_serv()
+            main.RamCloud2.start_serv()
+            main.RamCloud3.start_serv()
+            main.RamCloud4.start_serv()
+            time.sleep(5)
+            data =  main.RamCloud1.status_serv() and main.RamCloud2.status_serv() and main.RamCloud3.status_serv() and main.RamCloud4.status_serv()
+            
 
-        main.step("\n********************Starting Up RAMCloud*********************")
-        main.RamCloud1.start_coor()
-        time.sleep(2)
-        main.RamCloud1.start_serv()
-        main.RamCloud2.start_serv()
-        main.RamCloud3.start_serv()
-        main.RamCloud4.start_serv()
-        time.sleep(5)
-        
-        main.step("\n********************Testing RAMCloud Startup**************")
-        data2 = main.RamCloud1.status_serv()
-        print(data2)
+        utilities.assert_equals(expect=main.TRUE,actual=data,onpass="RamCloud is up!",onfail="RamCloud is down...")
+        main.step("Testing startup ONOS")   
+        data = main.ONOS1.isup() and main.ONOS2.isup() and main.ONOS3.isup() and main.ONOS4.isup()
         for i in range(3):
-            if data2 == main.FALSE:
-                main.RamCloud1.stop_serv()
-                main.RamCloud2.stop_serv()
-                main.RamCloud3.stop_serv()
-                main.RamCloud4.stop_serv()
-                main.RamCloud1.stop_coor()
-                main.RamCloud1.start_coor()
-                time.sleep(2)
-                main.RamCloud1.start_serv()
-                main.RamCloud2.start_serv()
-                main.RamCloud3.start_serv()
-                main.RamCloud4.start_serv()
-                time.sleep(5)
-                data2 = main.RamCloud1.status_serv()
+            if data == main.FALSE: 
+                #main.log.report("Something is funny... restarting ONOS")
+                #main.ONOS1.stop()
+                time.sleep(3)
+                #main.ONOS1.start()
+                #time.sleep(5) 
+                data = main.ONOS1.isup() and main.ONOS2.isup() and main.ONOS3.isup() and main.ONOS4.isup()
             else:
                 break
-        utilities.assert_equals(expect=main.TRUE,actual=data2,onpass="RAMCloud is up!",onfail="RAMCloud is down...")
-        if data2==main.FALSE:
-            main.log.report("RAMCloud is Down, Exiting the Test!")
-            main.cleanup()
-            main.exit()
+        utilities.assert_equals(expect=main.TRUE,actual=data,onpass="ONOS is up and running!",onfail="ONOS didn't start...")
+        time.sleep(20)
+           
+#**********************************************************************************************************************************************************************************************
+#Assign Controllers
+#This test first checks the ip of a mininet host, to be certain that the mininet exists(Host is defined in Params as <CASE1><destination>).
+#Then the program assignes each ONOS instance a single controller to a switch(To be the initial master), then assigns all controllers.
+#NOTE: The reason why all four controllers are assigned although one was already assigned as the master is due to the 'ovs-vsctl set-controller' command erases all present controllers if
+#      the controllers already assigned to the switch are not specified.
 
-        main.step("\n************************Starting Up ONOS and Rest*****************")
-        main.ONOS1.start()
-        time.sleep(10)
-        main.ONOS2.start()
-        main.ONOS3.start()
-        main.ONOS4.start()
-        main.ONOS1.start_rest()
-        time.sleep(5)
-        test = main.ONOS1.rest_status()
-        for i in range(3):
-            if test == main.FALSE:
-                main.ONOS1.start_rest()
-                time.sleep(5)
-                test = main.ONOS1.rest_status()
-            else:
-                break
-        
-        main.step("\n************************Testing ONOS Startup***************")
-        data3 = main.ONOS1.isup()
-        for i in range(3):
-            if data3 == main.FALSE:
-                main.log.report("ONOS did not start, restarting ONOS")
-                main.ONOS1.stop()
-                main.ONOS2.stop()
-                main.ONOS3.stop()
-                main.ONOS4.stop()
-                time.sleep(2)
-                main.ONOS1.start()
-                time.sleep(10)
-                main.ONOS2.start()
-                main.ONOS3.start()
-                main.ONOS4.start()
-                data3 = main.ONOS1.isup()
-            else:
-                break
-        utilities.assert_equals(expect=main.TRUE,actual=data3,onpass="ONOS is up!",onfail="ONOS is down...")
-        if data3==main.FALSE:
-            main.log.report("ONOS did not START!! Exiting the Test")
-            main.cleanup()
-            main.exit() 
-
-        main.step("\n****************************Testing Mininet Startup***************")
-        data4 = main.Mininet1.checkIP(main.params['CASE1']['destination'])
-        utilities.assert_equals(expect=main.TRUE,actual=data4,onpass="Host IP address configured",onfail="Host IP address not configured")
-
-        finalAssert = data1 and data2 and data3
-        utilities.assert_equals(expect=main.TRUE,actual=finalAssert,onpass="Good to Go!",onfail="NO GO FOR LAUNCH")
-
-#*****************************************************************************************
-
-    def CASE2(self,main) :
+    def CASE2(self,main) :    #Make sure mininet exists, then assign controllers to switches
         import time
-        main.case("\nAssign ONOS Controllers to Switches and run Initial Ping Test")
-        main.step("\n**********************Assign initial master controller to switches**********************")
-        for i in range(25):
+        main.log.report("Check if mininet started properly, then assign controllers ONOS 1,2,3 and 4")
+        main.case("Checking if one MN host exists")
+        main.step("Host IP Checking using checkIP")
+        result = main.Mininet1.checkIP(main.params['CASE1']['destination'])
+        main.step("Verifying the result")
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Host IP address configured",onfail="Host IP address not configured")
+        main.step("assigning ONOS controllers to switches")
+        for i in range(25): 
             if i < 3:
-                main.Mininet1.assign_sw_controller(sw=str(i+1),ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'])
+                j=i+1
+                main.Mininet1.assign_sw_controller(sw=str(j),ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'])
                 time.sleep(1)
-            elif i>=3 and i <5:
-                main.Mininet1.assign_sw_controller(sw=str(i+1),ip1=main.params['CTRL']['ip2'],port1=main.params['CTRL']['port2'])
+                main.Mininet1.assign_sw_controller(sw=str(j),count=4,ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'],ip2=main.params['CTRL']['ip2'],port2=main.params['CTRL']['port2'],ip3=main.params['CTRL']['ip3'],port3=main.params['CTRL']['port3'],ip4=main.params['CTRL']['ip4'],port4=main.params['CTRL']['port4'])
+            elif i >= 3 and i < 5:
+                j=i+1
+                main.Mininet1.assign_sw_controller(sw=str(j),ip1=main.params['CTRL']['ip2'],port1=main.params['CTRL']['port2'])
                 time.sleep(1)
-            elif i>=5 and i<15:
-                main.Mininet1.assign_sw_controller(sw=str(i+1),ip1=main.params['CTRL']['ip3'],port1=main.params['CTRL']['port3'])
+                main.Mininet1.assign_sw_controller(sw=str(j),count=4,ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'],ip2=main.params['CTRL']['ip2'],port2=main.params['CTRL']['port2'],ip3=main.params['CTRL']['ip3'],port3=main.params['CTRL']['port3'],ip4=main.params['CTRL']['ip4'],port4=main.params['CTRL']['port4'])
+            elif i >= 5 and i < 15:
+                j=i+1
+                main.Mininet1.assign_sw_controller(sw=str(j),ip1=main.params['CTRL']['ip3'],port1=main.params['CTRL']['port3'])
                 time.sleep(1)
-            else: 
-                main.Mininet1.assign_sw_controller(sw=str(i+16),ip1=main.params['CTRL']['ip4'],port1=main.params['CTRL']['port4'])
-                time.sleep(1)
-        
-        main.step("\n**********************Assign all ONOS instances to all Switches*************************")
-        for i in range(25):
-            if i < 15:
-                main.Mininet1.assign_sw_controller(sw=str(i+1),ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'],ip2=main.params['CTRL']['ip2'],port2=main.params['CTRL']['port2'],ip3=main.params['CTRL']['ip3'],port3=main.params['CTRL']['port3'],ip4=main.params['CTRL']['ip4'],port4=main.params['CTRL']['port4'])                
-                time.sleep(1)
+                main.Mininet1.assign_sw_controller(sw=str(j),count=4,ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'],ip2=main.params['CTRL']['ip2'],port2=main.params['CTRL']['port2'],ip3=main.params['CTRL']['ip3'],port3=main.params['CTRL']['port3'],ip4=main.params['CTRL']['ip4'],port4=main.params['CTRL']['port4'])
             else:
-                main.Mininet1.assign_sw_controller(sw=str(i+16),ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'],ip2=main.params['CTRL']['ip2'],port2=main.params['CTRL']['port2'],ip3=main.params['CTRL']['ip3'],port3=main.params['CTRL']['port3'],ip4=main.params['CTRL']['ip4'],port4=main.params['CTRL']['port4'])                
-       
-
-    def CASE3(self,main):
-        main.case("\nPerforming Initial Ping Test")
-        main.step("\n**********************Initial Ping Test***************")
-        count = 1
-        i = 6
-        while i < 16:
-            main.log.info("\n\t\t\th" + str(i) + " IS PINGING h" + str(i+25) )
-            strtTime = time.time()
-            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
-            if ping == main.FALSE and count<6:
-                count+=1
-                i = 6
-                main.log.info("Ping failed, making attempt number " + str(count)+" in 2 seconds")
+                j=i+16
+                main.Mininet1.assign_sw_controller(sw=str(j),ip1=main.params['CTRL']['ip4'],port1=main.params['CTRL']['port4'])
                 time.sleep(2)
-            elif ping == main.FALSE and count==6:
-                main.log.error("Ping test failed")
-                i = 17
-                result = main.FALSE
-            elif ping == main.TRUE:
-                i += 1
-                result = main.TRUE
-        endTime = time.time()
-        if result == main.TRUE:
-            main.log.report("\tTime to complete ping test: " + str(round(endTime-strtTime,2))+ " seconds")
-        else:
-            main.log.report("\tPING TEST FAILED!")
-        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOSS!!!! HOST IS NOT REACHABLE!!!!!!")
+                main.Mininet1.assign_sw_controller(sw=str(j),count=4,ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'],ip2=main.params['CTRL']['ip2'],port2=main.params['CTRL']['port2'],ip3=main.params['CTRL']['ip3'],port3=main.params['CTRL']['port3'],ip4=main.params['CTRL']['ip4'],port4=main.params['CTRL']['port4'])
+        main.Mininet1.get_sw_controller("s1")       
+        time.sleep(10)
+ 
+# **********************************************************************************************************************************************************************************************
+#Add Flows
+#Deletes any remnant flows from any previous test, add flows from the file labeled <FLOWDEF>, then runs the check flow test
+#NOTE: THE FLOWDEF FILE MUST BE PRESENT ON TESTON VM!!! TestON will copy the file from its home machine into /tmp/flowtmp on the machine the ONOS instance is present on
 
-
-
-    def CASE4(self,main):
-        main.case("\nWhat happens when 3 of the ONOS instances die?")
-        main.step("\n********************Removing 3 ONOS instances****************************")
-        main.ONOS2.stop()
-        main.ONOS3.stop()
-        main.ONOS4.stop()
-        main.step("\n*******************Checking for the correct topology*********************")
-        data1 = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
-        print("%s" % data1)
-        for i in range(10):
-            if data1 == main.FALSE:
-                time.sleep(5)
-                data1 = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
-            else:
-                break
-        main.step("\n********************Running PING Test****************************")
-        count = 1
-        i = 6
-        while i < 16:
-            main.log.info("\n\t\t\tH" + str(i) + " is PINGING H" + str(i+25))
-            strtTime = time.time()
-            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
-            if ping == main.FALSE and count<6:
-                count+=1
-                i = 6
-                main.log.info("Ping failed, making attempt number " + str(count)+" in 2 seconds")
-                time.sleep(2)
-            elif ping == main.FALSE and count==6:
-                main.log.error("Ping test failed")
-                i = 17
-                result2 = main.FALSE
-            elif ping == main.TRUE:
-                i += 1
-                result2 = main.TRUE
-        endTime = time.time()
-        if result2 == main.TRUE:
-            main.log.report("\tTime to complete ping test: " + str(round(endTime-strtTime,2))+ " seconds")
-        else:
-            main.log.report("\tPING TEST FAILED!")
-        finalResult = data1 and result2
-        utilities.assert_equals(expect=main.TRUE,actual=finalResult,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOSS!!!! HOST IS NOT REACHABLE!!!!!!")
-        time.sleep(5)
-
-
-    def CASE5(self,main):
-        main.case("\nRestart the 3 ONOS instances and run a PING test")
-        main.step("\n************************Bringing Back up ONOS Instances*****************************")
-        main.ONOS2.start()
-        main.ONOS3.start()
-        main.ONOS4.start()
-        time.sleep(4)
-        main.step("\n********************Running PING Test****************************")
-        count = 1
-        i = 6
-        while i < 16:
-            main.log.info("\n\t\t\tH" + str(i) + " is PINGING H" + str(i+25))
-            strtTime = time.time()
-            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
-            if ping == main.FALSE and count<6:
-                count+=1
-                i = 6
-                main.log.info("Ping failed, making attempt number " + str(count)+" in 2 seconds")
-                time.sleep(2)
-            elif ping == main.FALSE and count==6:
-                main.log.error("Ping test failed")
-                i = 17
-                result2 = main.FALSE
-            elif ping == main.TRUE:
-                i += 1
-                result2 = main.TRUE
-        endTime = time.time()
-        if result2 == main.TRUE:
-            main.log.report("\tTime to complete ping test: " + str(round(endTime-strtTime,2))+ " seconds")
-        else:
-            main.log.report("\tPING TEST FAILED!")
-        finalResult = result2
-        utilities.assert_equals(expect=main.TRUE,actual=finalResult,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOSS!!!! HOST IS NOT REACHABLE!!!!!!")
-        time.sleep(5)
-       
-
-    def CASE6(self,main):
-        main.case("Bring links between S1 and S2 down, then ping untill all hosts are reachable or fail after 10 attempts")
+    def CASE3(self,main) :    #Delete any remnant flows, then add flows, and time how long it takes flow tables to update
+        main.log.report("Delete any flows from previous tests, then add flows from FLOWDEF file, then wait for switch flow tables to update")
         import time
-        main.step("\n*****************Bringing Link DOWN!!!************************")
-        data1 = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
-        utilities.assert_equals(expect=main.TRUE,actual=data1,onpass="Link Brought DOWN!",onfail="Link still up...")
-        main.step("\n******************Waiting for Topology Convergence****************")
+        main.case("Taking care of these flows!") 
+        main.step("Cleaning out any leftover flows...")
+        #main.ONOS1.delete_flow("all")
         strtTime = time.time()
-        data2 = main.FALSE
-        data2 = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],str(int(main.params['NR_Links'])-2))
-        print("hello world")
-        for i in range(2):
-            if data2 == main.FALSE:
-                time.sleep(5)
-                data2 = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],str(int(main.params['NR_Links'])-2))
-            else:
-                break
-        utilities.assert_equals(expect=main.TRUE,actual=data2,onpass="Topology Converged",onfail="Topology FAILED to Converge")
-        main.case("\n*******************Ping Test***********************")
-        count = 1
-        i = 6
-        while i < 16:
-            main.log.info("\n\t\t\tH" + str(i) + " is PINGING H" + str(i+25))
-            strtTime = time.time()
-            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
-            if ping == main.FALSE and count<6:
-                count+=1
-                i = 6
-                main.log.info("Ping failed, making attempt number " + str(count)+" in 2 seconds")
-                time.sleep(2)
-            elif ping == main.FALSE and count==6:
-                main.log.error("Ping test failed")
-                i = 17
-                data3 = main.FALSE
-            elif ping == main.TRUE:
-                i += 1
-                data3 = main.TRUE
-        endTime = time.time()
-        if data3 == main.TRUE:
-            main.log.report("\tTime to complete ping test: " + str(round(endTime-strtTime,2))+ " seconds")
-        else:
-            main.log.report("\tPING TEST FAILED!")
-        utilities.assert_equals(expect=main.TRUE,actual=data3,onpass="Ping test PASSED!",onfail="Ping Test FAILED!!!!")
-        finalResult = data1 and data2 and data3
-        utilities.assert_equals(expect=main.TRUE,actual=finalResult,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOSS!!!! HOST IS NOT REACHABLE!!!!!!")
-        time.sleep(5)
+        main.ONOS1.rm_intents()
+        print("world")
+        main.ONOS1.add_intents()
+        time.sleep(2)
+        main.ONOS1.add_intents()
+        print("hello")
+       # main.ONOS1.add_flow(main.params['FLOWDEF']['testONip'],main.params['FLOWDEF']['user'],main.params['FLOWDEF']['password'],main.params['FLOWDEF']['flowDef'])
+        main.case("Checking flows")
        
-    def CASE31(self,main) : 
-        import time
-        main.case("\nClear out flows, then add flows from FLOWDEF file")
-        main.step("\n\n***************Cleaning out OLD flows!*************")
-        main.ONOS1.delete_flow("all")
-        main.step("\n\n***************Adding Flows from FLOWDEF File**********")
-        strtTime = time.time()
-        main.ONOS1.add_flow(main.params['FLOWDEF'])
-        main.step("\n\n**************Checking Flows***********************")
         count = 1
         i = 6
-        while i <16:
-            main.log.info("\n\t\t\t\th" + str(i) + " IS PINGING h" + str(i+25))
+        while i < 16 :
+            main.log.info("\n\t\t\t\th"+str(i)+" IS PINGING h"+str(i+25) )
             ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
             if ping == main.FALSE and count < 9:
-                count +=1
+                count = count + 1
                 i = 6
-                main.log.info("Ping failed, making attempt number " + str(count) + " in 2 seconds")
+                main.log.info("Ping failed, making attempt number "+str(count)+" in 2 seconds")
                 time.sleep(2)
-            elif ping == main.FALSE and count == 9:
+            elif ping == main.FALSE and count ==9:
                 main.log.error("Ping test failed")
                 i = 17
                 result = main.FALSE
             elif ping == main.TRUE:
-                i = i+1
+                i = i + 1
                 result = main.TRUE
         endTime = time.time()
         if result == main.TRUE:
-            main.log.report("\tTime to add flows: " + str(round(endTime-strtTime,2))+" seconds")
+            main.log.report("\tTime to add flows: "+str(round(endTime-strtTime,2))+" seconds")
         else:
             main.log.report("\tFlows failed check")
+
         result2 = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
-        finalResult = result and result2
-        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Flows added and Checked!",onfail="Flows did not add properly")
+        main.step("Verifying the result")
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Flow check PASS",onfail="Flow check FAIL")
+
+#**********************************************************************************************************************************************************************************************
+#This test case removes Controllers 2,3, and 4 then performs a ping test.
+#The assign controller is used because the ovs-vsctl module deletes all current controllers when a new controller is assigned.
+#The ping test performs single pings on hosts from opposite sides of the topology. If one ping fails, the test waits 5 seconds before trying again.
+#If the ping test fails 6 times, then the test case will return false
+    def CASE41(self,main) :
+        main.log.report("Testing Removal")
+        time.sleep(10)
+        main.ONOS2.stop()
+        time.sleep(10)
+        main.ONOS3.stop()
+        time.sleep(10)
+        main.ONOS4.stop()
+        time.sleep(15)
+        strtTime = time.time() 
+        result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
+        for i in range(10):
+            if result == main.FALSE:
+                time.sleep(5)
+                result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
+            else:
+                break
+
+        count = 1
+        i = 6
+        while i < 16 :
+            main.log.info("\n\t\t\t\th"+str(i)+" IS PINGING h"+str(i+25) )
+            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
+            if ping == main.FALSE and count < 6:
+                count = count + 1
+                i = 6
+                main.log.info("Ping failed, making attempt number "+str(count)+" in 2 seconds")
+                time.sleep(2)
+            elif ping == main.FALSE and count ==6:
+                main.log.error("Ping test failed")
+                i = 17
+                result = main.FALSE
+            elif ping == main.TRUE:
+                i = i + 1
+                result = main.TRUE
+        endTime = time.time() 
+        if result == main.TRUE:
+            main.log.report("\tTime to complete ping test: "+str(round(endTime-strtTime,2))+" seconds")
+        else:
+            main.log.report("\tPING TEST FAIL")
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOST, HOST IS NOT REACHABLE")
+        time.sleep(10)
+        main.ONOS2.start() 
+        main.ONOS3.start()
+        main.ONOS4.start() 
+        time.sleep(20)
 
 
+    def CASE4(self,main) :
+        main.log.report("Remove ONOS 2,3,4 then ping until all hosts are reachable or fail after 6 attempts")
+        import time
+        for i in range(25):
+            if i < 15:
+                j=i+1
+                main.Mininet1.assign_sw_controller(sw=str(j),ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'])  #Assigning a single controller removes all other controllers
+            else:
+                j=i+16
+                main.Mininet1.assign_sw_controller(sw=str(j),ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'])
+      
+        strtTime = time.time() 
+        result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
+        for i in range(10):
+            if result == main.FALSE:
+                time.sleep(5)
+                result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
+            else:
+                break
 
-    def CASE21(self,main) : 
+        count = 1
+        i = 6
+        while i < 16 :
+            main.log.info("\n\t\t\t\th"+str(i)+" IS PINGING h"+str(i+25) )
+            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
+            if ping == main.FALSE and count < 6:
+                count = count + 1
+                i = 6
+                main.log.info("Ping failed, making attempt number "+str(count)+" in 2 seconds")
+                time.sleep(2)
+            elif ping == main.FALSE and count ==6:
+                main.log.error("Ping test failed")
+                i = 17
+                result = main.FALSE
+            elif ping == main.TRUE:
+                i = i + 1
+                result = main.TRUE
+        endTime = time.time() 
+        if result == main.TRUE:
+            main.log.report("\tTime to complete ping test: "+str(round(endTime-strtTime,2))+" seconds")
+        else:
+            main.log.report("\tPING TEST FAIL")
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOST, HOST IS NOT REACHABLE")
+        time.sleep(10)
+
+# **********************************************************************************************************************************************************************************************
+#This test case restores the controllers removed by Case 4 then performs a ping test.
+
+    def CASE5(self,main) :
+        main.log.report("Restore ONOS 2,3,4 then ping until all hosts are reachable or fail after 6 attempts")
+        import time
+        for i in range(25): 
+            if i < 3:
+                j=i+1
+                main.Mininet1.assign_sw_controller(sw=str(j),ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'])
+                time.sleep(1)
+                main.Mininet1.assign_sw_controller(sw=str(j),count=4,ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'],ip2=main.params['CTRL']['ip2'],port2=main.params['CTRL']['port2'],ip3=main.params['CTRL']['ip3'],port3=main.params['CTRL']['port3'],ip4=main.params['CTRL']['ip4'],port4=main.params['CTRL']['port4'])
+            elif i >= 3 and i < 5:
+                j=i+1
+                main.Mininet1.assign_sw_controller(sw=str(j),ip1=main.params['CTRL']['ip2'],port1=main.params['CTRL']['port2'])
+                time.sleep(1)
+                main.Mininet1.assign_sw_controller(sw=str(j),count=4,ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'],ip2=main.params['CTRL']['ip2'],port2=main.params['CTRL']['port2'],ip3=main.params['CTRL']['ip3'],port3=main.params['CTRL']['port3'],ip4=main.params['CTRL']['ip4'],port4=main.params['CTRL']['port4'])
+            elif i >= 5 and i < 15:
+                j=i+1
+                main.Mininet1.assign_sw_controller(sw=str(j),ip1=main.params['CTRL']['ip3'],port1=main.params['CTRL']['port3'])
+                time.sleep(1)
+                main.Mininet1.assign_sw_controller(sw=str(j),count=4,ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'],ip2=main.params['CTRL']['ip2'],port2=main.params['CTRL']['port2'],ip3=main.params['CTRL']['ip3'],port3=main.params['CTRL']['port3'],ip4=main.params['CTRL']['ip4'],port4=main.params['CTRL']['port4'])
+            else:
+                j=i+16
+                main.Mininet1.assign_sw_controller(sw=str(j),ip1=main.params['CTRL']['ip4'],port1=main.params['CTRL']['port4'])
+                main.Mininet1.assign_sw_controller(sw=str(j),count=4,ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'],ip2=main.params['CTRL']['ip2'],port2=main.params['CTRL']['port2'],ip3=main.params['CTRL']['ip3'],port3=main.params['CTRL']['port3'],ip4=main.params['CTRL']['ip4'],port4=main.params['CTRL']['port4'])
+                time.sleep(1)
+        strtTime = time.time() 
+        result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
+        for i in range(10):
+            if result == main.FALSE:
+                time.sleep(5)
+                result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
+            else:
+                break
+
+        count = 1
+        i = 6
+        while i < 16 :
+            main.log.info("\n\t\t\t\th"+str(i)+" IS PINGING h"+str(i+25) )
+            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
+            if ping == main.FALSE and count < 6:
+                count = count + 1
+                i = 6
+                main.log.info("Ping failed, making attempt number "+str(count)+" in 2 seconds")
+                time.sleep(2)
+            elif ping == main.FALSE and count ==6:
+                main.log.error("Ping test failed")
+                i = 17
+                result = main.FALSE
+            elif ping == main.TRUE:
+                i = i + 1
+                result = main.TRUE
+        endTime = time.time()
+        if result == main.TRUE:
+            main.log.report("\tTime to complete ping test: "+str(round(endTime-strtTime,2))+" seconds")
+        else:
+            main.log.report("\tPING TEST FAILED")
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOST, HOST IS NOT REACHABLE")
+
+# **********************************************************************************************************************************************************************************************
+#Brings a link that all flows pass through in the mininet down, then runs a ping test to view reroute time
+
+    def CASE6(self,main) :
+        main.log.report("Bring Link between s1 and s2 down, then ping until all hosts are reachable or fail after 10 attempts")
+        import time
+        main.case("Bringing Link down... ")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Link DOWN!",onfail="Link not brought down...")
+        time.sleep(10)
+        strtTime = time.time() 
+        result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],str(int(main.params['NR_Links'])-2))
+        for i in range(10):
+            if result == main.FALSE:
+                time.sleep(5)
+                result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],str(int(main.params['NR_Links'])-2))
+            else:
+                break
+
+        count = 1
+        i = 6
+        while i < 16 :
+            main.log.info("\n\t\t\t\th"+str(i)+" IS PINGING h"+str(i+25) )
+            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
+            if ping == main.FALSE and count < 10:
+                count = count + 1
+                main.log.info("Ping failed, making attempt number "+str(count)+" in 2 seconds")
+                i = 6
+                time.sleep(2)
+            elif ping == main.FALSE and count == 10:
+                main.log.error("Ping test failed")
+                i = 17
+                result = main.FALSE
+            elif ping == main.TRUE:
+                i = i + 1
+                result = main.TRUE
+        endTime = time.time()
+        if result == main.TRUE:
+            main.log.report("\tTime to complete ping test: "+str(round(endTime-strtTime,2))+" seconds")
+        else:
+            main.log.report("\tPING TEST FAILED")
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOST, HOST IS NOT REACHABLE")
+
+# **********************************************************************************************************************************************************************************************
+#Brings the link that Case 6 took down  back up, then runs a ping test to view reroute time
+
+    def CASE7(self,main) :
+        main.log.report("Bring Link between s1 and s2 up, then ping until all hosts are reachable or fail after 10 attempts")
+        import time
+        main.case("Bringing Link up... ")
+        result = main.Mininet1.link(END1='s1',END2='s3',OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Link UP!",onfail="Link not brought up...")
+        time.sleep(10) 
+        strtTime = time.time() 
+        result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],str(int(main.params['NR_Links'])-2))
+        for i in range(10):
+            if result == main.FALSE:
+                time.sleep(15)
+                result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],str(int(main.params['NR_Links'])-2))
+            else:
+                break
+
+        strtTime = time.time()
+        count = 1
+        i = 6
+        while i < 16 :
+            main.log.info("\n\t\t\t\th"+str(i)+" IS PINGING h"+str(i+25) )
+            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
+            if ping == main.FALSE and count < 10:
+                count = count + 1
+                main.log.info("Ping failed, making attempt number "+str(count)+" in 2 seconds")
+                i = 6
+                time.sleep(2)
+            elif ping == main.FALSE and count ==10:
+                main.log.error("Ping test failed")
+                i = 17
+                result = main.FALSE
+            elif ping == main.TRUE:
+                i = i + 1
+                result = main.TRUE
+        endTime = time.time()
+        if result == main.TRUE:
+            main.log.report("\tTime to complete ping test: "+str(round(endTime-strtTime,2))+" seconds")
+        else:
+            main.log.report("\tPING TESTS FAILED")
+        data = main.Mininet1.link(END1='s1',END2='s3',OPTION="up")
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOST, HOST IS NOT REACHABLE")
+
+
+# ******************************************************************************************************************************************************************
+# Test Device Discovery function by yanking s6:s6-eth0 interface and re-plug it into a switch
+
+    def CASE21(self,main) :
         import json
-        main.case("Test device discovery function by attaching, metaching, moving host1 from s1 -> s6 -> s1. Per mininet naming, when switching ports, the host attaches will still remain as 's1-eth1' throughout the entire test")
-        main.step("\n\n******Checking that the initial host MAC/IP exists on the mininet******")
+        main.log.report("Test device discovery function, by attach, detach, move host h1 from s1->s6->s1. Per mininet naming, switch port the host attaches will remain as 's1-eth1' throughout the test.")
+        main.log.report("Check initially hostMAC/IP exist on the mininet...")
         host = main.params['YANK']['hostname']
         mac = main.params['YANK']['hostmac']
-        hostip = main.params['YANK']['hostip']
         RestIP1 = main.params['RESTCALL']['restIP1']
         RestPort = main.params['RESTCALL']['restPort']
         url = main.params['RESTCALL']['restURL']
-        t_topowait = 0
-        t_restwait = 10
-        main.log.report("Wait time from topo change to ping set to " + str(t_topowait))
-        main.log.report("Wait time from ping to rest call set to " + str(t_restwait))
-        time.sleep(t_topowait)
-        main.log.info("\n\t\t\t\t Ping: Issue 1 ping from " + str(host) + " to generate arp to switch. Ping result is not important")
+       
+        t_topowait = 5
+        t_restwait = 5
+        main.log.report( "Wait time from topo change to ping set to " + str(t_topowait))
+        main.log.report( "Wait time from ping to rest call set to " + str(t_restwait))
+        #print "host=" + host + ";  RestIP=" + RestIP1 + ";  RestPort=" + str(RestPort)
+        time.sleep(t_topowait) 
+        main.log.info("\n\t\t\t\t ping issue one ping from " + str(host) + " to generate arp to switch. Ping result is not important" )
         ping = main.Mininet1.pingHost(src = str(host),target = "10.0.0.254")
         time.sleep(t_restwait)
-        Reststatus, Swtich, Port, MAC = main.ONOS1.find_host(RestIP1,RestPort,url,hostip)
-        main.log.report("Number of hosts with IP=10.0.0.1 found by ONOS is: " + str(Reststatus))
-        if Reststatus ==1:
-            main.log.report("\t PASSED - Found host IP = " + hostip + "; MAC = " + "".join(MAC)+"; attached to switchDPPID = " + "".join(Switch)+ "; at port = " + "".join(Port))
+        Reststatus, Switch, Port = main.ONOS1.find_host(RestIP1,RestPort,url, mac)
+        main.log.report("Number of host with MAC address = " + mac + " found by ONOS is: " + str(Reststatus))
+        if Reststatus == 1:
+            main.log.report("\t PASSED - Found host mac = " + mac + ";  attached to switchDPID = " +"".join(Switch) + "; at port = " + str(Port[0]))
             result1 = main.TRUE
-        elif Reststatus >1:
-            main.log.report("\t FAILED - Host " + host + " with MAC:" + mac + " has " + str(Reststatus) + " duplicated IP addresses. FAILED")
+        elif Reststatus > 1:
+            main.log.report("\t FAILED - Host " + host + " with MAC:" + mac + " has " + str(Reststatus) + " duplicated mac  addresses. FAILED")
             main.log.report("switches are: " + "; ".join(Switch))
             main.log.report("Ports are: " + "; ".join(Port))
-            main.log.report("MACS are: " + "; ".join(MAC))
             result1 = main.FALSE
-        else:
-            main.log.report("\]t FAILED - Host " + host + " with MAC:" + mac + " does not exist. FAILED")
+        elif Reststatus == 0 and Switch == []:
+            main.log.report("\t FAILED - Host " + host + " with MAC:" + mac + " does not exist. FAILED")
+            result1 = main.FALSE
+        else:# check if rest server is working
+            main.log.error("Issue with find host")
             result1 = main.FALSE
 
-#*****************Step to yank out s1-eth1 from s1
 
-        main.step("Yank out s1-eth1")
-        main.log.report("Yankout s6-eth1 (link to h1) from s1")
+        ##### Step to yank out "s1-eth1" from s1, which is on autoONOS1 #####
+
+        main.log.report("Yank out s1-eth1")
+        main.case("Yankout s6-eth1 (link to h1) from s1")
         result = main.Mininet1.yank(SW=main.params['YANK']['sw1'],INTF=main.params['YANK']['intf'])
         time.sleep(t_topowait)
         utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Yank command suceeded",onfail="Yank command failed...")
-       
-        main.step("\n\n Ping: Issue 1 ping from " + str(host) + " to generate arp to switch. Ping result is not important")
+
+        main.log.info("\n\t\t\t\t ping issue one ping from " + str(host) + " to generate arp to switch. Ping result is not important" )
         ping = main.Mininet1.pingHost(src = str(host),target = "10.0.0.254")
         time.sleep(t_restwait)
-        Reststatus, Switch, Port, MAC = main.ONOS1.find_host(RestIP1,RestPort,url,hostip)
-        main.log.report("Number of hosts with IP=10.0.0.1 found by ONOS is: " + str(Reststatus))
-        if Reststatus ==1:
-            main.log.report("\tFAILED - Found host IP = " + hostip + "; MAC = " + "".join(MAC) + "".join(Port))
+        Reststatus, Switch, Port = main.ONOS1.find_host(RestIP1,RestPort,url, mac)
+
+        main.log.report("Number of host with MAC = " + mac + " found by ONOS is: " + str(Reststatus))
+        if Reststatus == 1:
+            main.log.report("\tFAILED - Found host MAC = " + mac + "; attached to switchDPID = " + "".join(Switch) + "; at port = " + str(Port))
             result2 = main.FALSE
-        elif Reststatus >1:
+        elif Reststatus > 1:
             main.log.report("\t FAILED - Host " + host + " with MAC:" + str(mac) + " has " + str(Reststatus) + " duplicated IP addresses. FAILED")
-            main.log.report("Switches are: " + "; ".join(Switch))
-            main.log.report("Ports are: " + "; ".join(Port))
-            main.log.report("MACs are: " + "; ".join(MAC))
-            result2 = main.FALSE
-        else:
-            main.log.report("\t PASSED - Host" + host + " with MAC:" + str(mac) + " does not exist. PASSED - host is not supposed to be attached to the switch.")
-            result2 = main.TRUE
-        utilities.assert_equals(expect=main.TRUE,actual=result2,onpass="s1-eth1 yanked!",onfail="s1-eth1 failed to be yanked!")
-
-# Step to plug "s1-eth1" to s6
-        main.step("Plug s1-eth1 into s6")
-        result3 = main.Mininet1.plug(SW=main.params['PLUG']['sw6'],INTF=main.params['PLUG']['intf'])
-        time.sleep(t_topowait)
-        utilities.assert_equals(expect=main.TRUE,actual=result3,onpass="Plug command suceeded",onfail="Plug command failed ... ")
-        main.step("\n\nPing issue one ping from " + str(host) + "to generate arp to switch. Ping result is not important")
-        ping = main.Mininet1.pingHost(src = str(host),target = "10.0.0.254")
-        time.sleep(t_restwait)
-        Reststatus, Switch, Port, MAC = main.ONOS1.find_host(RestIP1,RestPort,url,hostip)
-
-        main.log.report("Number of hosts with IP=10.0.0.1 found by ONOS is: " + str(Reststatus))
-        if Reststatus ==1:
-            main.log.report("\t PASSED - Found host IP = " + hostip + "; MAC = " + "".join(MAC) + "; attached to switchDPID = " + "".join(Switch) + "; at port = " + "".join(Port))
-            result4 = main.TRUE
-        elif Reststatus >1:
-            main.log.report("\t FAILED - Host " + host + " with MAC: " + str(mac) + " has " + str(Reststatus) + "duplicated IP addresses. FAILED")
             main.log.report("switches are: " + "; ".join(Switch))
             main.log.report("Ports are: " + "; ".join(Port))
             main.log.report("MACs are: " + "; ".join(MAC))
-            result4 = main.FALSE
-        else:
-            main.log.report("\t FAILED - Host " + host + " with MAC: " + str(mac) + " does not exist. FAILED")
-            result4 = main.FALSE
-
-# Step to put "s1-eth1" back to s1
-        main.step("Move s1-eth1 back to s1")
-        result5 = main.Mininet1.yank(SW=main.params['YANK']['sw6'],INTF=main.params['YANK']['intf'])
+            result2 = main.FALSE
+        elif Reststatus == 0 and Switch == []:
+            main.log.report("\t PASSED - Host " + host + " with MAC:" + str(mac) + " does not exist. PASSED - host is not supposed to be attached to the switch.")
+            result2 = main.TRUE
+        else:# check if rest server is working
+            main.log.error("Issue with find host")
+            result2 = main.FALSE
+         
+        ##### Step to plug "s1-eth1" to s6, which is on autoONOS3  ######
+        main.log.report("Plug s1-eth1 into s6")
+        main.case("Plug s1-eth1 to s6")
+        result = main.Mininet1.plug(SW=main.params['PLUG']['sw6'],INTF=main.params['PLUG']['intf'])
         time.sleep(t_topowait)
-        result6 = main.Mininet1.plug(SW=main.params['PLUG']['sw1'],INTF=main.params['PLUG']['intf'])
-        utilities.assert_equals(expect=main.TRUE,actual=(result5 and result6),onpass="Yank/Plug command suceeded",onfail="Yank/Plug command failed...")   
-        main.log.info("\n\t\t\t\t ping issue one ping from" + str(host) + "to generate arp to switch. Ping result is not important" )   
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Plug command suceeded",onfail="Plug command failed...")
+        main.log.info("\n\t\t\t\t ping issue one ping from " + str(host) + " to generate arp to switch. Ping result is not important" )
+
         ping = main.Mininet1.pingHost(src = str(host),target = "10.0.0.254")
         time.sleep(t_restwait)
-        Reststatus, Switch, Port, MAC = main.ONOS1.find_host(RestIP1,RestPort,url, hostip)
+        Reststatus, Switch, Port = main.ONOS1.find_host(RestIP1,RestPort,url, mac)
+
+        main.log.report("Number of host with MAC " + mac + " found by ONOS is: " + str(Reststatus))
+        if Reststatus == 1:
+            main.log.report("\tPASSED - Found host MAC = " + mac + "; attached to switchDPID = " + "".join(Switch) + "; at port = " + str(Port[0]))
+            result3 = main.TRUE
+        elif Reststatus > 1:
+            main.log.report("\t FAILED - Host " + host + " with MAC:" + str(mac) + " has " + str(Reststatus) + " duplicated IP addresses. FAILED")
+            main.log.report("switches are: " + "; ".join(Switch))
+            main.log.report("Ports are: " + "; ".join(Port))
+            main.log.report("MACs are: " + "; ".join(MAC))            
+            result3 = main.FALSE
+        elif Reststatus == 0 and Switch == []:
+            main.log.report("\t FAILED - Host " + host + " with MAC:" + str(mac) + " does not exist. FAILED")
+            result3 = main.FALSE
+        else:# check if rest server is working
+            main.log.error("Issue with find host")
+            result3 = main.FALSE
+
+        ###### Step to put interface "s1-eth1" back to s1"#####
+        main.log.report("Move s1-eth1 back on to s1")
+        main.case("Move s1-eth1 back to s1")
+        result = main.Mininet1.yank(SW=main.params['YANK']['sw6'],INTF=main.params['YANK']['intf'])
+        time.sleep(t_topowait)
+        result = main.Mininet1.plug(SW=main.params['PLUG']['sw1'],INTF=main.params['PLUG']['intf'])
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Yank/Plug command suceeded",onfail="Yank/Plug command failed...")
+        main.log.info("\n\t\t\t\t ping issue one ping from " + str(host) + " to generate arp to switch. Ping result is not important" )
+
+        ping = main.Mininet1.pingHost(src = str(host),target = "10.0.0.254")
+        time.sleep(t_restwait)
+        Reststatus, Switch, Port = main.ONOS1.find_host(RestIP1,RestPort,url, mac)
 
         main.log.report("Number of host with IP=10.0.0.1 found by ONOS is: " + str(Reststatus))
         if Reststatus == 1:
-            main.log.report("\tPASSED - Found host IP = " + hostip + "; MAC = " + "".join(MAC) + "; attached to switchDPID = " + "".join(Switch) + "; at port = " + "".join(Port))
-            result7 = main.TRUE
+            main.log.report("\tPASSED - Found host MAC = " + mac + "; attached to switchDPID = " + "".join(Switch) + "; at port = " + str(Port[0]))
+            result4 = main.TRUE
         elif Reststatus > 1:
             main.log.report("\t FAILED - Host " + host + " with MAC:" + str(mac) + " has " + str(Reststatuas) + " duplicated IP addresses. FAILED")
             main.log.report("switches are: " + "; ".join(Switch))
             main.log.report("Ports are: " + "; ".join(Port))
-            main.log.report("MACs are: " + "; ".join(MAC))      
-            result7 = main.FALSE
-        else:   
+            main.log.report("MACs are: " + "; ".join(MAC))            
+            result4 = main.FALSE
+        elif Reststatus == 0 and Switch == []:
             main.log.report("\t FAILED -Host " + host + " with MAC:" + str(mac) + " does not exist. FAILED")
-            result7 = main.FALSE
+            result4 = main.FALSE
+        else:# check if rest server is working
+            main.log.error("Issue with find host")
+            result4 = main.FALSE
+        time.sleep(20)
+        Reststatus, Switch, Port = main.ONOS1.find_host(RestIP1,RestPort,url,mac)
+        main.log.report("Number of host with IP=10.0.0.1 found by ONOS is: " + str(Reststatus))
+        if Reststatus ==1:
+            main.log.report("\t FAILED - Host " + host + "with MAC:" + str(mac) + "was still found after expected timeout")
+        elif Reststatus>1:
+            main.log.report("\t FAILED - Host " + host + "with MAC:" + str(mac) + "was still found after expected timeout(multiple found)")
+        elif Reststatus==0:
+            main.log.report("\t PASSED - Device cleared after timeout")
 
-        result = result1 and result2 and result3 and result4 and result5 and result6 and result7
+        result = result1 and result2 and result3 and result4
         utilities.assert_equals(expect=main.TRUE,actual=result,onpass="DEVICE DISCOVERY TEST PASSED PLUG/UNPLUG/MOVE TEST",onfail="DEVICE DISCOVERY TEST FAILED")
 
-    def CASE7(self, main) : 
-        import time
-        main.case("Bring Link between s1 and s2 up, then ping untill all hosts are reachable or fail after 10 attemtps!")
-        main.step("Bringing Link up... " )
-        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
-        utilities.assert_equlas(expect=main.TRUE,actual=result,onpass="Link UP!",onfail="Link not brought up...")
-        main.step("\n\n\t\tPing Test!")
-        strtTime = time.time()
-        result2 = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
-        for i in range(2):
-            if result2 == main.FALSE:
-                time.sleep(5)
-                result2 = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
-            else:
-                break
-        strtTime = time.time()
+# Run a pure ping test. 
+
+    def CASE31(self, main):
+        main.log.report("Performing Ping Test")        
         count = 1
         i = 6
-        while i <16 :
-            main.log.info("\n\t\t\t\th" + str(i) + " IS PINGING h" + str(i+25))
+        while i < 16 :
+            main.log.info("\n\t\t\t\th"+str(i)+" IS PINGING h"+str(i+25) )
+            strtTime = time.time()
             ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
-            if ping ==main.FALSE and count<10:
-                count +=1
-                main.log.info("Ping failed, making attempt number " + str(count) + " in 2 seconds")
+            if ping == main.FALSE and count < 6:
+                count = count + 1
                 i = 6
+                main.log.info("Ping failed, making attempt number "+str(count)+" in 2 seconds")
                 time.sleep(2)
-            elif ping ==main.FALSE and count==10:
+            elif ping == main.FALSE and count ==6:
                 main.log.error("Ping test failed")
                 i = 17
-                result3 = main.FALSE
-            elif ping ==main.TRUE:
-                i += 1
-                result3 = main.TRUE
+                result = main.FALSE
+            elif ping == main.TRUE:
+                i = i + 1
+                result = main.TRUE
         endTime = time.time()
-        if result3 ==main.TRUE:
-            main.log.report("\t Time to complete ping test: " + str(round(endTime-strtTime,2)) + " seconds")
+        if result == main.TRUE:
+            main.log.report("\tTime to complete ping test: "+str(round(endTime-strtTime,2))+" seconds")
         else:
-            main.log.report("\tPing Tests FAILED!!")
-        finalResult = result and result2 and result3 and result4
-        utilities.assert_equals(expect=main.TRUE,actual=finalResult,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOST, HOST IS NOT REACHABLE")
-                
+            main.log.report("\tPING TEST FAIL")
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOST, HOST IS NOT REACHABLE")
 
 
+    def CASE66(self, main):
+        main.log.report("Checking ONOS logs for exceptions")
+        count = 0
+        check1 = main.ONOS1.check_exceptions()
+        main.log.report("Exceptions in ONOS1 logs: \n" + check1)
+        check2 = main.ONOS2.check_exceptions()
+        main.log.report("Exceptions in ONOS2 logs: \n" + check2)
+        check3 = main.ONOS3.check_exceptions()
+        main.log.report("Exceptions in ONOS3 logs: \n" + check3)
+        check4 = main.ONOS4.check_exceptions()
+        main.log.report("Exceptions in ONOS4 logs: \n" + check4)
+        result = main.TRUE
+        if (check1 or check2 or check3 or check4):
+            result = main.FALSE
+            count = len(check1.splitlines()) + len(check2.splitlines()) + len(check3.splitlines()) + len(check4.splitlines())
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="No Exceptions found in the logs",onfail=str(count) + " Exceptions were found in the logs")
+        main.Mininet2.stop_tcpdump()
+
+
+    def CASE8(self,main) :
+        main.log.report("Testing Removal of Zookeeper")
+        main.Zookeeper2.stop()
+        main.Zookeeper3.stop()
+        main.Zookeeper4.stop()
+        strtTime = time.time() 
+        result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
+        for i in range(10):
+            if result == main.FALSE:
+                time.sleep(5)
+                result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],main.params['NR_Links'])
+            else:
+                break
+
+        count = 1
+        i = 6
+        while i < 16 :
+            main.log.info("\n\t\t\t\th"+str(i)+" IS PINGING h"+str(i+25) )
+            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
+            if ping == main.FALSE and count < 6:
+                count = count + 1
+                i = 6
+                main.log.info("Ping failed, making attempt number "+str(count)+" in 2 seconds")
+                time.sleep(2)
+            elif ping == main.FALSE and count ==6:
+                main.log.error("Ping test failed")
+                i = 17
+                result = main.FALSE
+            elif ping == main.TRUE:
+                i = i + 1
+                result = main.TRUE
+        endTime = time.time() 
+        if result == main.TRUE:
+            main.log.report("\tTime to complete ping test: "+str(round(endTime-strtTime,2))+" seconds")
+        else:
+            main.log.report("\tPING TEST FAIL")
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOST, HOST IS NOT REACHABLE")
+        time.sleep(10)
+        main.Zookeeper2.start() 
+        main.Zookeeper3.start()
+        main.Zookeeper4.start() 
+        time.sleep(10)
+
+
+    def CASE67(self, main) :
+        main.case("Flapping link s1-s2")
+        main.log.report("Toggling of link s1-s2 multiple times")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],str(int(main.params['NR_Links'])-2))
+        for i in range(10):
+            if result == main.FALSE:
+                time.sleep(15)
+                result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],str(int(main.params['NR_Links'])-2))
+            else:
+                break
+
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="up")
+        result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],str(int(main.params['NR_Links'])))
+        for i in range(10):
+            if result == main.FALSE:
+                time.sleep(15)
+                result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],str(int(main.params['NR_Links'])))
+            else:
+                break
+        result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
+        result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],str(int(main.params['NR_Links'])-2))
+        for i in range(10):
+            if result == main.FALSE:
+                time.sleep(15)
+                result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],str(int(main.params['NR_Links'])-2))
+            else:
+                break
+           
+
+
+    def CASE101(self,main) :
+        import time
+        import json
+        import re
+        main.case("Testing the Intent Framework of ONOS")
+        
+#*****************************************************************************************
+#*****************************************************************************************
+# The first part of CASE 101 will be assigning the master controllers to the switches
+# and to check that each one is assigned correctly. 
+#*****************************************************************************************
+#*****************************************************************************************
+        main.step("Assigning Master Controllers to the Switches and check")
+        for i in range(25):
+            if i<3:
+                j=i+1
+                main.Mininet1.assign_sw_controller(sw=str(j),ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'])
+            elif i>=3 and i<5:
+                j=i+1
+                main.Mininet1.assign_sw_controller(sw=str(j),ip1=main.params['CTRL']['ip2'],port1=main.params['CTRL']['port1'])
+            elif i>=5 and i<15:
+                j=j+1
+                main.Mininet1.assign_sw_controller(sw=str(j),ip1=main.params['CTRL']['ip3'],port1=main.params['CTRL']['port1'])
+            else:
+                j=i+16
+                main.Mininet1.assign_sw_controller(sw=str(j),ip1=main.params['CTRL']['ip4'],port1=main.params['CTRL']['port1'])
+        result = main.TRUE
+        for i in range(25):
+            if i<3:
+                j=i+1
+                response=main.Mininet1.get_sw_controller("s"+str(j))
+                print("Response is " + str(response))
+                if re.search("tcp:"+main.params['CTRL']['ip1'],response) :
+                    result = result and main.TRUE
+                else:
+                    result = main.FALSE
+            elif i>=3 and i<5:
+                j=i+1
+                response=main.Mininet1.get_sw_controller("s"+str(j))
+                if re.search("tcp:"+main.params['CTRL']['ip2'],response) :
+                    result = result and main.TRUE
+                else:
+                    result = main.FALSE
+            elif i>=5 and i<15:
+                j=j+1
+                response=main.Mininet1.get_sw_controller("s"+str(j))
+                if re.search("tcp:"+main.params['CTRL']['ip3'],response) :
+                    result = result and main.TRUE
+                else:
+                    result = main.FALSE
+            else:
+                j=i+16
+                response=main.Mininet1.get_sw_controller("s"+str(j))
+                if re.search("tcp:"+main.params['CTRL']['ip4'],response) :
+                    result = result and main.TRUE
+                else:
+                    result = main.FALSE
+            print(result)
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Master Controllers assigned Properly",onfail="FAILED TO ASSIGN MASTER CONTROLLERS!")
+
+#*****************************************************************************************
+#*****************************************************************************************
+# Assign all controllers to the switches as backups. Run a get-controller on each
+# switch to ensure that all controllers have been assigned properly to its switches
+#*****************************************************************************************
+#*****************************************************************************************
+        main.step("Assigning all Controllers as Backups to Switches and Check")
+        for i in range(25):
+            if i<15:
+                j=i+1
+                main.Mininet1.assign_sw_controller(sw=str(j),count=4,ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'],ip2=main.params['CTRL']['ip2'],port2=main.params['CTRL']['port2'],ip3=main.params['CTRL']['ip3'],port3=main.params['CTRL']['port3'],ip4=main.params['CTRL']['ip4'],port4=main.params['CTRL']['port4'])
+            else:
+                j=i+16
+                main.Mininet1.assign_sw_controller(sw=str(j),count=4,ip1=main.params['CTRL']['ip1'],port1=main.params['CTRL']['port1'],ip2=main.params['CTRL']['ip2'],port2=main.params['CTRL']['port2'],ip3=main.params['CTRL']['ip3'],port3=main.params['CTRL']['port3'],ip4=main.params['CTRL']['ip4'],port4=main.params['CTRL']['port4'])
+        result = main.TRUE
+        time.sleep(5)
+        for i in range(25):
+            if i<15:
+                j=i+1
+                response=main.Mininet1.get_sw_controller("s"+str(j))
+                if re.search("tcp:"+main.params['CTRL']['ip1'],response) and re.search("tcp:"+main.params['CTRL']['ip2'],response) and re.search("tcp:"+main.params['CTRL']['ip3'],response) and re.search("tcp:"+main.params['CTRL']['ip4'],response):
+                    result = result and main.TRUE
+                else:
+                    result = main.FALSE
+            else:
+                j=i+16
+                response=main.Mininet1.get_sw_controller("s"+str(j))
+                if re.search("tcp:"+main.params['CTRL']['ip1'],response) and re.search("tcp:"+main.params['CTRL']['ip2'],response) and re.search("tcp:"+main.params['CTRL']['ip3'],response) and re.search("tcp:"+main.params['CTRL']['ip4'],response):
+                    result = result and main.TRUE
+                else:
+                    result = main.FALSE
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Controllers assigned properly to all switches",onfail="FAILED TO ASSIGN CONTROLLERS PROPERLY!")
+
+
+        
+#*****************************************************************************************
+#*****************************************************************************************
+# Installation of Intents. This part will run run a forloop and add an intent from 
+# h6 to h31, h7 to h32, etc and the other way as well, h31 to h6, h32 to h7, etc.
+# then Check by dumping the flows on SW2 and check for flows going bidirectionally.
+#*****************************************************************************************
+#*****************************************************************************************
+        main.step("Install intents and Check for Installation of Flows")
+        intentIP = main.params['INTENTREST']['intentIP']
+        intentPort=main.params['INTENTREST']['intentPort']
+        intentURL=main.params['INTENTREST']['intentURL']
+        count = 1
+        for i in range(6,16):
+            time.sleep(1)
+            srcMac = '00:00:00:00:00:' + str(hex(i)[2:]).zfill(2)
+            dstMac = '00:00:00:00:00:'+str(hex(i+10)[2:])
+            #srcDPID=str(i)
+            #dstDPID=str(i+10)
+            srcDPID = '00:00:00:00:00:00:10:'+str(i).zfill(2)
+            dstDPID= '00:00:00:00:00:00:20:' +str(i+25)
+            main.ONOS1.add_intent(intent_id=str(count),src_dpid=srcDPID,dst_dpid=dstDPID,src_mac=srcMac,dst_mac=dstMac,intentIP=intentIP,intentPort=intentPort,intentURL=intentURL)
+            count +=1
+            dstMac = '00:00:00:00:00:' + str(hex(i)[2:]).zfill(2)
+            srcMac = '00:00:00:00:00:'+str(hex(i+10)[2:])
+            #srcDPID=str(i)
+            #dstDPID=str(i+10)
+            dstDPID = '00:00:00:00:00:00:10:'+str(i).zfill(2)
+            srcDPID= '00:00:00:00:00:00:20:' +str(i+25)
+            main.ONOS1.add_intent(intent_id=str(count),src_dpid=srcDPID,dst_dpid=dstDPID,src_mac=srcMac,dst_mac=dstMac,intentIP=intentIP,intentPort=intentPort,intentURL=intentURL)
+            count+=1
+        result = main.TRUE
+        response = main.Mininet1.check_flows(sw="s1")
+        print(response)
+        for i in range(6,16):
+            if re.search("dl_src=00:00:00:00:00:"+''.join('%02x'%i),response) and re.search("dl_src=00:00:00:00:00:"+''.join('%02x'%(i+10)),response) and re.search("dl_dst=00:00:00:00:00:"+''.join('%02x'%i),response) and re.search("dl_dst=00:00:00:00:00:"+''.join('%02x'%(i+10)),response):   
+                result = result and main.TRUE
+            else:
+                result = main.FALSE
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Flows added Properly",onfail="Flows were not added properly")
+ 
+#*****************************************************************************************
+#*****************************************************************************************
+# This step will run a ping test from h6 to h31, h7 to h32, etc as an End to End test
+# All of these pings should run through. 
+#*****************************************************************************************
+#*****************************************************************************************
+        main.step("Ping Test as End to End Test that the Intents were Correctly Installed")
+        main.log.report("Performing Ping Test")        
+        count = 1
+        i = 6
+        while i < 16 :
+            main.log.info("\n\t\t\t\th"+str(i)+" IS PINGING h"+str(i+25) )
+            strtTime = time.time()
+            ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+25))
+            if ping == main.FALSE and count < 6:
+                count = count + 1
+                i = 6
+                main.log.info("Ping failed, making attempt number "+str(count)+" in 2 seconds")
+                time.sleep(2)
+            elif ping == main.FALSE and count ==6:
+                main.log.error("Ping test failed")
+                i = 17
+                result = main.FALSE
+            elif ping == main.TRUE:
+                i = i + 1
+                result = main.TRUE
+        endTime = time.time()
+        if result == main.TRUE:
+            main.log.report("\tTime to complete ping test: "+str(round(endTime-strtTime,2))+" seconds")
+        else:
+            main.log.report("\tPING TEST FAIL")
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="NO PACKET LOSS, HOST IS REACHABLE",onfail="PACKET LOST, HOST IS NOT REACHABLE")
+        
+#*****************************************************************************************
+#*****************************************************************************************
+# Removing a single intent. Then check to ensure that intent was found by calling
+# show_intent. Then check that flows are removed by pinging. 
+#*****************************************************************************************
+#*****************************************************************************************
+        main.step("Delete a single intent and ensure that flows are deleted")
+        main.ONOS1.del_intent(intentIP=intentIP,intentPort=intentPort,intentURL=intentURL,intent_id="intent_id=10")
+        time.sleep(2)
+        response = main.ONOS1.show_intent(intentIP=intentIP,intentPort=intentPort,intentURL=intentURL,intent_id=10)
+        if re.search("INTENT_NOT_FOUND",response):
+            main.log.report("Intent Removed Properly!")
+        else:
+            main.log.report("ERROR REMOVING INTENT")
+        main.log.report("Performing Ping Test")        
+        count = 1
+        for count in range(4):
+            ping = main.Mininet1.pingHost(src="h10",target="h35")
+            if ping==main.FALSE and count == 3:
+                main.log.info("Ping failed as expected. Intent Deleted")
+                result = main.TRUE
+            elif ping == main.TRUE:
+                main.log.error("Intent was not deleted correctly")
+                result = main.FALSE
+            else:
+                main.log.info("So far so good, attempting "+str(4-count) + " more times")
+        if result == main.TRUE:
+            main.log.report("\tIntent Deleted!")
+        else:
+            main.log.report("\tINTENT FAILED TO BE DELETED")
+        utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Intent Deleted Properly - Step Passed",onfail="INTENT NOT DELETED - STEP FAILED")
+        main.ONOS1.del_intent(intentIP=intentIP,intentPort=intentPort,intentURL=intentURL)
+
+
+#*****************************************************************************************
+#*****************************************************************************************
+# Install a bad intent. Then, ensure that we are able to get rid of it
+# Installing an intent as ID=200, from a random dpid/mac to random dpid/mac. Then, 
+# check to make sure the intent is there, then delete it and ensure that it is gone
+#*****************************************************************************************
+#*****************************************************************************************
+
+
+        main.step("Installing incorrect intent and checking for deletion")
+        main.ONOS1.add_intent(intent_id=str(200),src_dpid="00:00:00:00:00:00:45:67",dst_dpid="00:00:00:00:00:32:21:10",src_mac="00:00:00:01:11:11",dst_mac="00:12:12:12:12:12",intentIP=intentIP,intentPort=intentPort,intentURL=intentURL)
+
+        
+        
+
+
+    def CASE10(self, main) :
+        import time
+        time.sleep(600)
diff --git a/TestON/tests/JamesTest/JamesTest.topo b/TestON/tests/JamesTest/JamesTest.topo
index 0819d37..3bfaa2f 100644
--- a/TestON/tests/JamesTest/JamesTest.topo
+++ b/TestON/tests/JamesTest/JamesTest.topo
@@ -130,10 +130,24 @@
             <COMPONENTS>
                 # Specify the Option for mininet
                 <arg1> --custom ~/mininet/custom/topo-onos4node.py </arg1>
-                <arg2> --topo mytopo </arg2>
+                <arg2> --topo mytopo --arp</arg2>
                 <controller> remote </controller>
              </COMPONENTS>
         </Mininet1>
 
+        <Mininet2>
+            <host>10.128.4.159</host>
+            <user>admin</user>
+            <password></password>
+            <type>RemoteMininetDriver</type>
+            <connect_order>14</connect_order>
+            <COMPONENTS>
+                # Specify the Option for mininet
+                <arg1> --custom ~/mininet/custom/topo-onos4node.py </arg1>
+                <arg2> --topo mytopo --arp</arg2>
+                <controller> remote </controller>
+             </COMPONENTS>
+        </Mininet2>
+
     </COMPONENT>
 </TOPOLOGY>
diff --git a/TestON/tests/JamesTest/RCOnosSanity4nodesJ.params.normal b/TestON/tests/JamesTest/RCOnosSanity4nodesJ.params.normal
new file mode 100644
index 0000000..f644d9f
--- /dev/null
+++ b/TestON/tests/JamesTest/RCOnosSanity4nodesJ.params.normal
@@ -0,0 +1,62 @@
+<PARAMS>
+    <testcases>1,2,3,31,6,7,6,7,4,6,7,6,7,5,6,7,6,7,41,6,7,6,7,5,6,7,6,7,66</testcases>
+    <tcpdump> 
+        <intf>eth0</intf>
+        <port>port 6633</port>
+        <filename>~/packet_captures/Sanity.pcap</filename>
+    </tcpdump>
+    <CASE1>       
+        <destination>h6</destination>
+        <target>h40</target>
+    </CASE1>       
+    <PING>
+        <source1>h7</source1>
+        <target1>h32</target1>
+        <source2>h8</source2>
+        <target2>h33</target2>
+    </PING>
+    <LINK>
+        <begin>s1</begin>
+        <end>s2</end>
+    </LINK>
+    <YANK>
+        <hostname>h1</hostname>
+        <hostip>10.0.0.1</hostip>
+        <hostmac>00:00:00:00:00:01</hostmac>
+	<sw1>s1</sw1>
+        <sw6>s6</sw6>
+        <intf>s1-eth1</intf>
+    </YANK>
+    <PLUG>
+        <intf>s1-eth1</intf>
+	<sw6>s6</sw6>
+	<sw1>s1</sw1>
+    </PLUG>
+    <CTRL>
+        <ip1>10.128.4.151</ip1>
+        <port1>6633</port1>
+        <ip2>10.128.4.152</ip2>
+        <port2>6633</port2>
+        <ip3>10.128.4.153</ip3>
+        <port3>6633</port3>
+        <ip4>10.128.4.154</ip4>
+        <port4>6633</port4>
+    </CTRL>
+    <INTENTREST>
+        <intentIP>10.128.4.151</intentIP>
+        <intentPort>8080</intentPort>
+        <intentURL>wm/onos/intent/high</intentURL>
+    </INTENTREST>
+    <RestIP>10.128.4.151</RestIP>
+    <RestIP2>10.128.4.152</RestIP2>
+    <RestIP3>10.128.4.153</RestIP3>
+    <RestIP4>10.128.4.154</RestIP4>
+    <NR_Switches>25</NR_Switches>
+    <NR_Links>50</NR_Links>
+    <RESTCALL>
+	<restIP1>10.128.4.151</restIP1>
+	<restIP2>10.128.4.152</restIP2>
+	<restPort>8080</restPort>
+	<restURL>/wm/onos/topology/hosts</restURL>
+    </RESTCALL>
+</PARAMS>      
diff --git a/TestON/tests/RCOnosSanity4nodesJ/RCOnosSanity4nodesJ.params b/TestON/tests/RCOnosSanity4nodesJ/RCOnosSanity4nodesJ.params
index 7fdbf88..f644d9f 100644
--- a/TestON/tests/RCOnosSanity4nodesJ/RCOnosSanity4nodesJ.params
+++ b/TestON/tests/RCOnosSanity4nodesJ/RCOnosSanity4nodesJ.params
@@ -1,5 +1,5 @@
 <PARAMS>
-    <testcases>1,2,3,31,67,6,7,6,7,4,6,7,5,6,7,41,6,7,5,6,7,66</testcases>
+    <testcases>1,2,3,31,6,7,6,7,4,6,7,6,7,5,6,7,6,7,41,6,7,6,7,5,6,7,6,7,66</testcases>
     <tcpdump> 
         <intf>eth0</intf>
         <port>port 6633</port>
diff --git a/TestON/tests/RCOnosSanity4nodesJ/RCOnosSanity4nodesJ.py b/TestON/tests/RCOnosSanity4nodesJ/RCOnosSanity4nodesJ.py
index a680ab4..f8cfca1 100644
--- a/TestON/tests/RCOnosSanity4nodesJ/RCOnosSanity4nodesJ.py
+++ b/TestON/tests/RCOnosSanity4nodesJ/RCOnosSanity4nodesJ.py
@@ -369,7 +369,7 @@
         main.case("Bringing Link down... ")
         result = main.Mininet1.link(END1=main.params['LINK']['begin'],END2=main.params['LINK']['end'],OPTION="down")
         utilities.assert_equals(expect=main.TRUE,actual=result,onpass="Link DOWN!",onfail="Link not brought down...")
-       
+        time.sleep(10)
         strtTime = time.time() 
         result = main.ONOS1.check_status_report(main.params['RestIP'],main.params['NR_Switches'],str(int(main.params['NR_Links'])-2))
         for i in range(10):