diff --git a/TestON/drivers/common/cli/emulator/mininetclidriver.py b/TestON/drivers/common/cli/emulator/mininetclidriver.py
index 0cfd804..41670f7 100644
--- a/TestON/drivers/common/cli/emulator/mininetclidriver.py
+++ b/TestON/drivers/common/cli/emulator/mininetclidriver.py
@@ -915,7 +915,7 @@
         else:
             main.log.error( "Connection failed to the host" )
 
-    def getIPAddress( self, host ):
+    def getIPAddress( self, host , proto='IPV4'):
         """
            Verifies the host's ip configured or not."""
         if self.handle:
@@ -931,7 +931,11 @@
                 main.cleanup()
                 main.exit()
 
-            pattern = "inet\saddr:(\d+\.\d+\.\d+\.\d+)"
+            pattern = ''
+            if proto == 'IPV4':
+                pattern = "inet\saddr:(\d+\.\d+\.\d+\.\d+)"
+            else:
+                pattern = "inet6\saddr:\s([\w,:]*)/"
             ipAddressSearch = re.search( pattern, response )
             main.log.info(
                 self.name +
diff --git a/TestON/tests/FUNCipv6Intent/Dependency/FUNCIpv6IntentFunction.py b/TestON/tests/FUNCipv6Intent/Dependency/FUNCIpv6IntentFunction.py
index ec1ae9c..6930ef3 100644
--- a/TestON/tests/FUNCipv6Intent/Dependency/FUNCIpv6IntentFunction.py
+++ b/TestON/tests/FUNCipv6Intent/Dependency/FUNCIpv6IntentFunction.py
@@ -117,11 +117,10 @@
         return main.FALSE
 
     # Discover hosts using arping incase pingall discovery failed
-    main.log.info( itemName + ": Discover host using arping" )
-    main.Mininet1.arping( srcHost=host1, dstHost=host2 )
-    main.Mininet1.arping( srcHost=host2, dstHost=host1 )
-    host1 = main.CLIs[ 0 ].getHost( mac=h1Mac )
-    host2 = main.CLIs[ 0 ].getHost( mac=h2Mac )
+    #main.log.info( itemName + ": Discover host using pingall" )
+    #main.Mininet1.pingall( protocol='IPv6' )
+    #host1 = main.CLIs[ 0 ].getHost( mac=h1Mac )
+    #host2 = main.CLIs[ 0 ].getHost( mac=h2Mac )
 
     # Check flows count in each node
     checkFlowsCount( main )
@@ -147,13 +146,14 @@
     checkFlowsState( main )
 
     # Ping hosts
-    firstPingResult = pingallHosts( main, hostNames )
+    #firstPingResult = ping6allHosts( main, hostNames )
+    firstPingResult = main.Mininet1.ping6pair(SRC=hostNames[0], TARGET=main.hostsData[ host2 ][ 'ipAddresses' ][ 0 ])
     if not firstPingResult:
         main.log.debug( "First ping failed, there must be" +
                        " something wrong with ONOS performance" )
 
     # Ping hosts again...
-    pingTemp = pingallHosts( main, hostNames )
+    pingTemp = main.Mininet1.ping6pair(SRC=hostNames[0], TARGET=main.hostsData[ host2 ][ 'ipAddresses' ][ 0 ])
     pingResult = pingResult and pingTemp
     if pingTemp:
         main.assertReturnString += 'Initial Pingall Passed\n'
@@ -405,7 +405,7 @@
     checkFlowsState( main )
 
     # Ping hosts
-    pingTemp = main.Mininet1.ping6pair(SRC=host1, TARGET='10:1:0::5')
+    pingTemp = main.Mininet1.ping6pair(SRC=host1, TARGET=main.hostsData[ host2 ][ 'ipAddresses' ][ 0 ])
     pingResult = pingResult and pingTemp
     if pingTemp:
         main.assertReturnString += 'Initial Ping6 pair Passed\n'
@@ -687,7 +687,7 @@
     checkFlowsState( main )
 
     # Run iperf to both host
-    iperfTemp = main.Mininet1.iperftcp( host1,host2,10 )
+    iperfTemp = main.Mininet1.iperftcp( host1,host2,timeout=10 )
     iperfResult = iperfResult and iperfTemp
     if iperfTemp:
         main.assertReturnString += 'Initial Iperf Passed\n'
@@ -717,7 +717,7 @@
             main.assertReturnString += 'Link Down Topology State Failed\n'
 
         # Run iperf to both host
-        iperfTemp = main.Mininet1.iperftcp( host1,host2,10 )
+        iperfTemp = main.Mininet1.iperftcp( host1,host2,timeout=10 )
         iperfResult = iperfResult and iperfTemp
         if iperfTemp:
             main.assertReturnString += 'Link Down Iperf Passed\n'
@@ -761,7 +761,7 @@
             main.assertReturnString += 'Link Up Topology State Failed\n'
 
         # Run iperf to both host
-        iperfTemp = main.Mininet1.iperftcp( host1,host2,10 )
+        iperfTemp = main.Mininet1.iperftcp( host1,host2,timeout=10 )
         iperfResult = iperfResult and iperfTemp
         if iperfTemp:
             main.assertReturnString += 'Link Up Iperf Passed\n'
@@ -1392,6 +1392,10 @@
     getDataResult = main.TRUE
     main.log.info( "Activating reactive forwarding app " )
     activateResult = main.CLIs[ 0 ].activateApp( "org.onosproject.fwd" )
+    main.CLIs[ 0 ].setCfg( "org.onosproject.fwd.ReactiveForwarding", "ipv6Forwarding", "true")
+    main.CLIs[ 0 ].setCfg( "org.onosproject.fwd.ReactiveForwarding", "matchIpv6Address", "true")
+    main.CLIs[ 0 ].setCfg( "org.onosproject.fwd.ReactiveForwarding", "ipv6Forwarding", "true")
+    main.CLIs[ 0 ].setCfg( "org.onosproject.fwd.ReactiveForwarding", "matchIpv6Address", "true")
     time.sleep( main.fwdSleep )
 
     for i in range( main.numCtrls ):
@@ -1400,7 +1404,7 @@
             main.log.warn( main.CLIs[ i ].apps() )
             main.log.warn( main.CLIs[ i ].appIDs() )
 
-    pingResult = main.Mininet1.pingall( timeout = 600 )
+    pingResult = main.Mininet1.pingall( protocol="IPv6", timeout = 600 )
     hostsJson = json.loads( main.CLIs[ 0 ].hosts() )
     hosts = main.Mininet1.getHosts().keys()
     # TODO: Make better use of new getHosts function
diff --git a/TestON/tests/FUNCipv6Intent/Dependency/newFuncTopo.py b/TestON/tests/FUNCipv6Intent/Dependency/newFuncTopo.py
index ff63bf9..d4731f3 100755
--- a/TestON/tests/FUNCipv6Intent/Dependency/newFuncTopo.py
+++ b/TestON/tests/FUNCipv6Intent/Dependency/newFuncTopo.py
@@ -48,52 +48,38 @@
         # Initialize topology
         Topo.__init__( self )
         # Switch S5 Hosts
-        # IPv4 only Host
         host1=self.addHost( 'h1', cls=IPv6Host, v6Addr='10:1:0::1/64' )
-        # IPv6 only Host
         host2=self.addHost( 'h2', cls=IPv6Host, v6Addr='1000::2/64' )
         # Dual Stack Host
-        host3=self.addHost( 'h3', cls=IPv6Host, v6Addr='2000::2/64' )
-        # VLAN hosts
+        host3=self.addHost( 'h3', cls=dualStackHost, v6Addr='2000::2/64' )
         host4=self.addHost( 'h4', cls=IPv6Host, v6Addr='3000::2/64' )
-        host5=self.addHost( 'h5', cls=IPv6Host,v6Addr='4000::2/64' )
-        # VPN-1 and VPN-2 Hosts
+        #VLAN
+        host5=self.addHost( 'h5', cls=VLANHost,v6Addr='4000::2/64' )
         host6=self.addHost( 'h6', cls=IPv6Host, v6Addr='11:1:0::2/64' )
         host7=self.addHost( 'h7', cls=IPv6Host, v6Addr='12:1:0::2/64' )
-        # Multicast Sender
         host8=self.addHost( 'h8', cls=IPv6Host, v6Addr='10:1:0::4/64' )
 
         # Switch S6 Hosts
-        # IPv4 only Host
         host9=self.addHost( 'h9', cls=IPv6Host, v6Addr='10:1:0::5/64' )
-        # IPv6 only Host
         host10=self.addHost( 'h10', cls=IPv6Host, v6Addr='1000::3/64' )
         # Dual Stack Host
-        host11=self.addHost( 'h11', cls=IPv6Host, v6Addr='2000::3/64' )
-        # VLAN hosts
+        host11=self.addHost( 'h11', cls=dualStackHost, v6Addr='2000::3/64' )
         host12=self.addHost( 'h12', cls=IPv6Host, v6Addr='3000::3/64' )
         host13=self.addHost( 'h13', cls=IPv6Host, v6Addr='4000::3/64' )
-        # VPN-1 and VPN-2 Hosts
         host14=self.addHost( 'h14', cls=IPv6Host, v6Addr='11:1:0::3/64' )
         host15=self.addHost( 'h15', cls=IPv6Host, v6Addr='12:1:0::3/64' )
-        # Multicast Receiver
         host16=self.addHost( 'h16', cls=IPv6Host, v6Addr='10:1:0::7/64' )
 
         # Switch S7 Hosts
-        # IPv4 only Host
         host17=self.addHost( 'h17', cls=IPv6Host, v6Addr='10:1:0::8/64' )
-        # IPv6 only Host
         host18=self.addHost( 'h18', cls=IPv6Host, v6Addr='1000::4/64' )
-        # Dual Stack Host
         host19=self.addHost( 'h19', cls=IPv6Host, v6Addr='10:1:0::9/64' )
-        # VLAN hosts
         host20=self.addHost( 'h20', cls=IPv6Host, v6Addr='100:1:0::4/64' )
         host21=self.addHost( 'h21', cls=IPv6Host, v6Addr='200:1:0::4/64' )
-        # VPN-1 and VPN-2 Hosts
         host22=self.addHost( 'h22', cls=IPv6Host, v6Addr='11:1:0::4/64' )
         host23=self.addHost( 'h23', cls=IPv6Host, v6Addr='12:1:0::4/64' )
-        # Multicast Receiver
-        host24=self.addHost( 'h24', cls=IPv6Host, v6Addr='10:1:0::10/64' )
+        # VLAN 
+        host24=self.addHost( 'h24', cls=VLANHost, v6Addr='4000::5/64' )
 
         s1 = self.addSwitch( 's1' )
         s2 = self.addSwitch( 's2' )
diff --git a/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.params b/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.params
index f70e399..c7b3c62 100644
--- a/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.params
+++ b/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.params
@@ -6,7 +6,7 @@
     # 12 - Assign switch to controller
     # 14 - Stop Mininet
 
-    <testcases>1,2,11,12,2000,14</testcases>
+    <testcases>1,2,11,12,13,2000,14</testcases>
 
     <SCALE>
         <size>1</size>
@@ -27,7 +27,6 @@
         <pull>false</pull>
         <branch>master</branch>
     </GIT>
-
     <SLEEP>
         <startup>15</startup>
         <reroute>5</reroute>
@@ -44,7 +43,7 @@
     # Intent tests params
     <SDNIP>
         <tcpProto>6</tcpProto>
-        <icmpProto>1</icmpProto>
+        <icmpProto>58</icmpProto>
         <srcPort>5001</srcPort>
         <dstPort>5001</dstPort>
     </SDNIP>
diff --git a/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.py b/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.py
index 9ee99fb..1c91540 100644
--- a/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.py
+++ b/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.py
@@ -166,7 +166,7 @@
                                  onpass="Successfully applied cell to " + \
                                         "environment",
                                  onfail="Failed to apply cell to environment " )
-
+ 
         main.step( "Creating ONOS package" )
         packageResult = main.ONOSbench.onosPackage()
         stepResult = packageResult
@@ -237,7 +237,7 @@
                                  onfail="Failed to start ONOS cli" )
 
         main.step( "Checking that ONOS is ready" )
-        for i in range( 10 ):
+        for i in range( 3 ):
             ready = True
             for i in range( int( main.scale[ 0 ] ) ):
                 output = main.CLIs[ i ].summary()
@@ -334,6 +334,20 @@
                                  onfail="Failed to assign switches to " +
                                         "controller" )
 
+    def CASE13( self, main ):
+        """
+        Discover all hosts and store its data to a dictionary
+        """
+        main.case( "Discover all hosts" )
+
+        stepResult = main.TRUE
+        main.step( "Discover all hosts using pingall " )
+        stepResult = main.intentFunction.getHostsData( main )
+        utilities.assert_equals( expect=main.TRUE,
+                                actual=stepResult,
+                                onpass="Successfully discovered hosts",
+                                onfail="Failed to discover hosts" )
+
     def CASE14( self, main ):
         """
             Stop mininet
@@ -413,7 +427,7 @@
                                  actual=stepResult,
                                  onpass=main.assertReturnString,
                                  onfail=main.assertReturnString )
-
+        """
         stepResult = main.TRUE
         main.step( "IPV6: Add point intents between h1 and h9" )
         main.assertReturnString = "Assertion Result for IPV6 point intent\n"
@@ -463,24 +477,27 @@
                                  actual=stepResult,
                                  onpass=main.assertReturnString,
                                  onfail=main.assertReturnString )
-        """
+        
         main.step( "SDNIP-ICMP: Add point intents between h1 and h9" )
-        main.assertReturnString = "Assertion Result for SDNIP-ICMP IPV4 using TCP point intents\n"
+        main.assertReturnString = "Assertion Result for SDNIP-ICMP IPV6 using ICMP point intents\n"
         mac1 = main.hostsData[ 'h1' ][ 'mac' ]
         mac2 = main.hostsData[ 'h9' ][ 'mac' ]
-        try:
-            ip1 = str( main.hostsData[ 'h1' ][ 'ipAddresses' ][ 0 ] ) + "/24"
-            ip2 = str( main.hostsData[ 'h9' ][ 'ipAddresses' ][ 0 ] ) + "/24"
-        except KeyError:
-            main.log.debug( "Key Error getting IP addresses of h1 | h9 in" +
-                            "main.hostsData" )
-            ip1 = main.Mininet1.getIPAddress( 'h1')
-            ip2 = main.Mininet1.getIPAddress( 'h9')
+        main.log.debug(mac2)
+
+        # TODO : Fix is IPv6 arg format
+        # when we install the intent "add-point-intent --ethType IPV6 --ethSrc 00:00:00:00:00:01 
+        # --ethDst 00:00:00:00:00:09 --ipProto 1 --ipSrc 10:1::1/128 --ipDst 10:1::5/128 
+        # of:0000000000000005/1 of:0000000000000006/1" controller reports following error :
+        # Malformed IP prefix string: 10:1::1. Address must take form "x.x.x.x/y" or "xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx/y"
+        #ip1 = main.Mininet1.getIPAddress( 'h1', proto='IPV6' )
+        #ip2 = main.Mininet1.getIPAddress( 'h9', proto='IPV6')
 
         ipProto = main.params[ 'SDNIP' ][ 'icmpProto' ]
         # Uneccessary, not including this in the selectors
-        tcp1 = main.params[ 'SDNIP' ][ 'srcPort' ]
-        tcp2 = main.params[ 'SDNIP' ][ 'dstPort' ]
+        #tcp1 = main.params[ 'SDNIP' ][ 'srcPort' ]
+        #tcp2 = main.params[ 'SDNIP' ][ 'dstPort' ]
+        ip1 = str( main.hostsData[ 'h1' ][ 'ipAddresses' ][ 0 ] ) + "/128"
+        ip2 = str( main.hostsData[ 'h9' ][ 'ipAddresses' ][ 0 ] ) + "/128"
 
         stepResult = main.intentFunction.pointIntent(
                                            main,
@@ -500,13 +517,13 @@
                                  actual=stepResult,
                                  onpass=main.assertReturnString,
                                  onfail=main.assertReturnString )
-
+        """
         main.step( "SDNIP-TCP: Add point intents between h1 and h9" )
-        main.assertReturnString = "Assertion Result for SDNIP-TCP IPV4 using ICMP point intents\n"
-        mac1 = main.hostsData[ 'h1' ][ 'mac' ]
-        mac2 = main.hostsData[ 'h9' ][ 'mac' ]
-        ip1 = str( main.hostsData[ 'h1' ][ 'ipAddresses' ][ 0 ] ) + "/32"
-        ip2 = str( main.hostsData[ 'h9' ][ 'ipAddresses' ][ 0 ] ) + "/32"
+        main.assertReturnString = "Assertion Result for SDNIP-TCP IPV6 using TCP point intents\n"
+        mac1 = main.hostsData[ 'h3' ][ 'mac' ]
+        mac2 = main.hostsData[ 'h11' ][ 'mac' ]
+        ip1 = str( main.hostsData[ 'h3' ][ 'ipAddresses' ][ 0 ] ) + "/128"
+        ip2 = str( main.hostsData[ 'h11' ][ 'ipAddresses' ][ 0 ] ) + "/128"
         ipProto = main.params[ 'SDNIP' ][ 'tcpProto' ]
         tcp1 = main.params[ 'SDNIP' ][ 'srcPort' ]
         tcp2 = main.params[ 'SDNIP' ][ 'dstPort' ]
@@ -514,10 +531,10 @@
         stepResult = main.intentFunction.pointIntentTcp(
                                            main,
                                            name="SDNIP-TCP",
-                                           host1="h1",
-                                           host2="h9",
-                                           deviceId1="of:0000000000000005/1",
-                                           deviceId2="of:0000000000000006/1",
+                                           host1="h3",
+                                           host2="h11",
+                                           deviceId1="of:0000000000000005/3",
+                                           deviceId2="of:0000000000000006/3",
                                            mac1=mac1,
                                            mac2=mac2,
                                            ethType="IPV4",
@@ -528,22 +545,22 @@
                                            tcp2=tcp2 )
 
         utilities.assert_equals( expect=main.TRUE,
-                             actual=stepResult,
+                                 actual=stepResult,
                                  onpass=main.assertReturnString,
                                  onfail=main.assertReturnString )
-
+        """
         main.step( "DUALSTACK1: Add point intents between h3 and h11" )
-        main.assertReturnString = "Assertion Result for Dualstack1 IPV4 with mac address point intents\n"
+        main.assertReturnString = "Assertion Result for Dualstack1 IPV6 with mac address point intents\n"
         stepResult = main.intentFunction.pointIntent(
                                        main,
                                        name="DUALSTACK1",
                                        host1="h3",
                                        host2="h11",
-                                       deviceId1="of:0000000000000005",
-                                       deviceId2="of:0000000000000006",
-                                       port1="3",
-                                       port2="3",
-                                       ethType="IPV4",
+                                       deviceId1="of:0000000000000005/3",
+                                       deviceId2="of:0000000000000006/3",
+                                       port1="",
+                                       port2="",
+                                       ethType="IPV6",
                                        mac1="00:00:00:00:00:03",
                                        mac2="00:00:00:00:00:0B",
                                        bandwidth="",
@@ -553,8 +570,8 @@
                                        ip2="",
                                        tcp1="",
                                        tcp2="",
-                                       sw1="s5",
-                                       sw2="s2",
+                                       sw1="",
+                                       sw2="",
                                        expectedLink=18 )
 
         utilities.assert_equals( expect=main.TRUE,
@@ -562,20 +579,20 @@
                                  onpass=main.assertReturnString,
                                  onfail=main.assertReturnString )
 
-        main.step( "VLAN: Add point intents between h5 and h21" )
-        main.assertReturnString = "Assertion Result for VLAN IPV4 with mac address point intents\n"
+        main.step( "VLAN: Add point intents between h5 and h24" )
+        main.assertReturnString = "Assertion Result for VLAN IPV6 with mac address point intents\n"
         stepResult = main.intentFunction.pointIntent(
                                        main,
                                        name="VLAN",
                                        host1="h5",
-                                       host2="h21",
+                                       host2="h24",
                                        deviceId1="of:0000000000000005/5",
-                                       deviceId2="of:0000000000000007/5",
+                                       deviceId2="of:0000000000000007/8",
                                        port1="",
                                        port2="",
-                                       ethType="IPV4",
+                                       ethType="IPV6",
                                        mac1="00:00:00:00:00:05",
-                                       mac2="00:00:00:00:00:15",
+                                       mac2="00:00:00:00:00:18",
                                        bandwidth="",
                                        lambdaAlloc=False,
                                        ipProto="",
@@ -583,17 +600,17 @@
                                        ip2="",
                                        tcp1="",
                                        tcp2="",
-                                       sw1="s5",
-                                       sw2="s2",
+                                       sw1="",
+                                       sw2="",
                                        expectedLink=18 )
 
         utilities.assert_equals( expect=main.TRUE,
                                  actual=stepResult,
                                  onpass=main.assertReturnString,
                                  onfail=main.assertReturnString )
-
-        main.step( "1HOP: Add point intents between h1 and h3" )
-        main.assertReturnString = "Assertion Result for 1HOP IPV4 with no mac address point intents\n"
+        
+        main.step( "1HOP: Add point intents between h1 and h9" )
+        main.assertReturnString = "Assertion Result for 1HOP IPV6 with no mac address point intents\n"
         stepResult = main.intentFunction.hostIntent( main,
                                               name='1HOP',
                                               host1='h1',
diff --git a/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.py.save b/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.py.save
new file mode 100644
index 0000000..854d5f3
--- /dev/null
+++ b/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.py.save
@@ -0,0 +1,625 @@
+# Testing the basic intent for ipv6 functionality of ONOS
+
+class FUNCipv6Intent:
+
+    def __init__( self ):
+        self.default = ''
+
+    def CASE1( self, main ):
+        import time
+        import imp
+        import re
+
+        """
+        - Construct tests variables
+        - GIT ( optional )
+            - Checkout ONOS master branch
+            - Pull latest ONOS code
+        - Building ONOS ( optional )
+            - Install ONOS package
+            - Build ONOS package
+        """
+
+        main.case( "Constructing test variables and building ONOS package" )
+        main.step( "Constructing test variables" )
+        main.caseExplanation = "This test case is mainly for loading " +\
+                               "from params file, and pull and build the " +\
+                               " latest ONOS package"
+        stepResult = main.FALSE
+
+        # Test variables
+        try:
+            main.testOnDirectory = re.sub( "(/tests)$", "", main.testDir )
+            main.apps = main.params[ 'ENV' ][ 'cellApps' ]
+            gitBranch = main.params[ 'GIT' ][ 'branch' ]
+            main.dependencyPath = main.testOnDirectory + \
+                                  main.params[ 'DEPENDENCY' ][ 'path' ]
+            main.topology = main.params[ 'DEPENDENCY' ][ 'topology' ]
+            main.scale = ( main.params[ 'SCALE' ][ 'size' ] ).split( "," )
+            if main.ONOSbench.maxNodes:
+                main.maxNodes = int( main.ONOSbench.maxNodes )
+            else:
+                main.maxNodes = 0
+            wrapperFile1 = main.params[ 'DEPENDENCY' ][ 'wrapper1' ]
+            wrapperFile2 = main.params[ 'DEPENDENCY' ][ 'wrapper2' ]
+            wrapperFile3 = main.params[ 'DEPENDENCY' ][ 'wrapper3' ]
+            main.startUpSleep = int( main.params[ 'SLEEP' ][ 'startup' ] )
+            main.checkIntentSleep = int( main.params[ 'SLEEP' ][ 'checkintent' ] )
+            main.removeIntentSleep = int( main.params[ 'SLEEP' ][ 'removeintent' ] )
+            main.rerouteSleep = int( main.params[ 'SLEEP' ][ 'reroute' ] )
+            main.fwdSleep = int( main.params[ 'SLEEP' ][ 'fwd' ] )
+            main.checkTopoAttempts = int( main.params[ 'SLEEP' ][ 'topoAttempts' ] )
+            gitPull = main.params[ 'GIT' ][ 'pull' ]
+            main.numSwitch = int( main.params[ 'MININET' ][ 'switch' ] )
+            main.numLinks = int( main.params[ 'MININET' ][ 'links' ] )
+            main.cellData = {} # for creating cell file
+            main.hostsData = {}
+            main.CLIs = []
+            main.ONOSip = []
+            main.assertReturnString = ''  # Assembled assert return string
+
+            main.ONOSip = main.ONOSbench.getOnosIps()
+            print main.ONOSip
+
+            # Assigning ONOS cli handles to a list
+            for i in range( 1,  main.maxNodes + 1 ):
+                main.CLIs.append( getattr( main, 'ONOScli' + str( i ) ) )
+
+            # -- INIT SECTION, ONLY RUNS ONCE -- #
+            main.startUp = imp.load_source( wrapperFile1,
+                                            main.dependencyPath +
+                                            wrapperFile1 +
+                                            ".py" )
+
+            main.intentFunction = imp.load_source( wrapperFile2,
+                                            main.dependencyPath +
+                                            wrapperFile2 +
+                                            ".py" )
+
+            main.topo = imp.load_source( wrapperFile3,
+                                         main.dependencyPath +
+                                         wrapperFile3 +
+                                         ".py" )
+
+            copyResult1 = main.ONOSbench.scp( main.Mininet1,
+                                              main.dependencyPath +
+                                              main.topology,
+                                              main.Mininet1.home,
+                                              direction="to" )
+            if main.CLIs:
+                stepResult = main.TRUE
+            else:
+                main.log.error( "Did not properly created list of ONOS CLI handle" )
+                stepResult = main.FALSE
+        except Exception as e:
+            main.log.exception(e)
+            main.cleanup()
+            main.exit()
+
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="Successfully construct " +
+                                        "test variables ",
+                                 onfail="Failed to construct test variables" )
+
+        if gitPull == 'True':
+            main.step( "Building ONOS in " + gitBranch + " branch" )
+            onosBuildResult = main.startUp.onosBuild( main, gitBranch )
+            stepResult = onosBuildResult
+            utilities.assert_equals( expect=main.TRUE,
+                                     actual=stepResult,
+                                     onpass="Successfully compiled " +
+                                            "latest ONOS",
+                                     onfail="Failed to compile " +
+                                            "latest ONOS" )
+        else:
+            main.log.warn( "Did not pull new code so skipping mvn " +
+                           "clean install" )
+        main.ONOSbench.getVersion( report=True )
+
+    def CASE2( self, main ):
+        """
+        - Set up cell
+            - Create cell file
+            - Set cell file
+            - Verify cell file
+        - Kill ONOS process
+        - Uninstall ONOS cluster
+        - Verify ONOS start up
+        - Install ONOS cluster
+        - Connect to cli
+        """
+
+        # main.scale[ 0 ] determines the current number of ONOS controller
+        main.numCtrls = int( main.scale[ 0 ] )
+
+        main.case( "Starting up " + str( main.numCtrls ) +
+                   " node(s) ONOS cluster" )
+        main.caseExplanation = "Set up ONOS with " + str( main.numCtrls ) +\
+                                " node(s) ONOS cluster"
+
+
+
+        #kill off all onos processes
+        main.log.info( "Safety check, killing all ONOS processes" +
+                       " before initiating environment setup" )
+
+        for i in range( main.maxNodes ):
+            main.ONOSbench.onosDie( main.ONOSip[ i ] )
+
+        print "NODE COUNT = ", main.numCtrls
+
+        tempOnosIp = []
+        for i in range( main.numCtrls ):
+            tempOnosIp.append( main.ONOSip[i] )
+
+        main.ONOSbench.createCellFile( main.ONOSbench.ip_address,
+                                       "temp", main.Mininet1.ip_address,
+                                       main.apps, tempOnosIp )
+
+        main.step( "Apply cell to environment" )
+        cellResult = main.ONOSbench.setCell( "temp" )
+        verifyResult = main.ONOSbench.verifyCell()
+        stepResult = cellResult and verifyResult
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="Successfully applied cell to " + \
+                                        "environment",
+                                 onfail="Failed to apply cell to environment " )
+ 
+        main.step( "Creating ONOS package" )
+        packageResult = main.ONOSbench.onosPackage()
+        stepResult = packageResult
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="Successfully created ONOS package",
+                                 onfail="Failed to create ONOS package" )
+
+        time.sleep( main.startUpSleep )
+        main.step( "Uninstalling ONOS package" )
+        onosUninstallResult = main.TRUE
+        for ip in main.ONOSip:
+            onosUninstallResult = onosUninstallResult and \
+                    main.ONOSbench.onosUninstall( nodeIp=ip )
+        stepResult = onosUninstallResult
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="Successfully uninstalled ONOS package",
+                                 onfail="Failed to uninstall ONOS package" )
+
+        time.sleep( main.startUpSleep )
+        main.step( "Installing ONOS package" )
+        onosInstallResult = main.TRUE
+        for i in range( main.numCtrls ):
+            onosInstallResult = onosInstallResult and \
+                    main.ONOSbench.onosInstall( node=main.ONOSip[ i ] )
+        stepResult = onosInstallResult
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="Successfully installed ONOS package",
+                                 onfail="Failed to install ONOS package" )
+
+        time.sleep( main.startUpSleep )
+        main.step( "Starting ONOS service" )
+        stopResult = main.TRUE
+        startResult = main.TRUE
+        onosIsUp = main.TRUE
+
+        for i in range( main.numCtrls ):
+            onosIsUp = onosIsUp and main.ONOSbench.isup( main.ONOSip[ i ] )
+        if onosIsUp == main.TRUE:
+            main.log.report( "ONOS instance is up and ready" )
+        else:
+            main.log.report( "ONOS instance may not be up, stop and " +
+                             "start ONOS again " )
+
+            for i in range( main.numCtrls ):
+                stopResult = stopResult and \
+                        main.ONOSbench.onosStop( main.ONOSip[ i ] )
+            for i in range( main.numCtrls ):
+                startResult = startResult and \
+                        main.ONOSbench.onosStart( main.ONOSip[ i ] )
+        stepResult = onosIsUp and stopResult and startResult
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="ONOS service is ready",
+                                 onfail="ONOS service did not start properly" )
+
+        main.step( "Start ONOS cli" )
+        cliResult = main.TRUE
+        for i in range( main.numCtrls ):
+            cliResult = cliResult and \
+                        main.CLIs[ i ].startOnosCli( main.ONOSip[ i ] )
+        stepResult = cliResult
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="Successfully start ONOS cli",
+                                 onfail="Failed to start ONOS cli" )
+
+        main.step( "Checking that ONOS is ready" )
+        for i in range( 10 ):
+            ready = True
+            for i in range( int( main.scale[ 0 ] ) ):
+                output = main.CLIs[ i ].summary()
+                if not output:
+                    ready = False
+            time.sleep( 30 )
+        utilities.assert_equals( expect=True, actual=ready,
+                                 onpass="ONOS summary command succeded",
+                                 onfail="ONOS summary command failed" )
+        if not ready:
+            main.cleanup()
+            main.exit()
+
+        main.step( "setup the ipv6NeighbourDiscovery" )
+        cfgResult1 = main.CLIs[0].setCfg( "org.onosproject.proxyarp.ProxyArp", "ipv6NeighborDiscovery", "true" )
+        cfgResult2 = main.CLIs[0].setCfg( "org.onosproject.provider.host.impl.HostLocationProvider", "ipv6NeighborDiscovery", "true" )
+        cfgResult = cfgResult1 and cfgResult2
+        utilities.assert_equals( expect=main.TRUE, actual=cfgResult,
+                                onpass="ipv6NeighborDiscovery cfg is set to true",
+                                onfail="Failed to cfg set ipv6NeighborDiscovery" )
+
+        # Remove the first element in main.scale list
+        main.scale.remove( main.scale[ 0 ] )
+
+        main.intentFunction.report( main )
+
+    def CASE11( self, main ):
+        """
+            Start Mininet topology with OF 1.3 switches
+        """
+        main.OFProtocol = "1.3"
+        main.log.report( "Start Mininet topology with OF 1.3 switches" )
+        main.case( "Start Mininet topology with OF 1.3 switches" )
+        main.caseExplanation = "Start mininet topology with OF 1.3 " +\
+                                "switches to test intents, exits out if " +\
+                                "topology did not start correctly"
+
+        main.step( "Starting Mininet topology with OF 1.3 switches" )
+        args = "--switch ovs,protocols=OpenFlow13"
+        topoResult = main.Mininet1.startNet( topoFile=main.dependencyPath +
+                                                      main.topology,
+                                             args=args )
+        stepResult = topoResult
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="Successfully loaded topology",
+                                 onfail="Failed to load topology" )
+        # Exit if topology did not load properly
+        if not topoResult:
+            main.cleanup()
+            main.exit()
+
+    def CASE12( self, main ):
+        """
+            Assign mastership to controllers
+        """
+        import re
+
+        main.case( "Assign switches to controllers" )
+        main.step( "Assigning switches to controllers" )
+        main.caseExplanation = "Assign OF " + main.OFProtocol +\
+                                " switches to ONOS nodes"
+
+        assignResult = main.TRUE
+        switchList = []
+
+        # Creates a list switch name, use getSwitch() function later...
+        for i in range( 1, ( main.numSwitch + 1 ) ):
+            switchList.append( 's' + str( i ) )
+
+        tempONOSip = []
+        for i in range( main.numCtrls ):
+            tempONOSip.append( main.ONOSip[ i ] )
+
+        assignResult = main.Mininet1.assignSwController( sw=switchList,
+                                                         ip=tempONOSip,
+                                                         port='6653' )
+        if not assignResult:
+            main.cleanup()
+            main.exit()
+
+        for i in range( 1, ( main.numSwitch + 1 ) ):
+            response = main.Mininet1.getSwController( "s" + str( i ) )
+            print( "Response is " + str( response ) )
+            if re.search( "tcp:" + main.ONOSip[ 0 ], response ):
+                assignResult = assignResult and main.TRUE
+            else:
+                assignResult = main.FALSE
+        stepResult = assignResult
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="Successfully assigned switches" +
+                                        "to controller",
+                                 onfail="Failed to assign switches to " +
+                                        "controller" )
+
+    def CASE13( self, main ):
+        """
+        Discover all hosts and store its data to a dictionary
+        """
+        main.case( "Discover all hosts" )
+
+        stepResult = main.TRUE
+        main.step( "Discover all hosts using pingall " )
+        stepResult = main.intentFunction.getHostsData( main )
+        utilities.assert_equals( expect=main.TRUE,
+                                actual=stepResult,
+                                onpass="Successfully discovered hosts",
+                                onfail="Failed to discover hosts" )
+
+    def CASE14( self, main ):
+        """
+            Stop mininet
+        """
+        main.log.report( "Stop Mininet topology" )
+        main.case( "Stop Mininet topology" )
+        main.caseExplanation = "Stopping the current mininet topology " +\
+                                "to start up fresh"
+
+        main.step( "Stopping Mininet Topology" )
+        topoResult = main.Mininet1.stopNet( )
+        stepResult = topoResult
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass="Successfully stop mininet",
+                                 onfail="Failed to stop mininet" )
+        # Exit if topology did not load properly
+        if not topoResult:
+            main.cleanup()
+            main.exit()
+
+    def CASE2000( self, main ):
+        """
+            add point intents between 2 hosts:
+                - Get device ids | ports
+                - Add point intents
+                - Check intents
+                - Verify flows
+                - Ping hosts
+                - Reroute
+                    - Link down
+                    - Verify flows
+                    - Check topology
+                    - Ping hosts
+                    - Link up
+                    - Verify flows
+                    - Check topology
+                    - Ping hosts
+                - Remove intents
+        """
+        import time
+        import json
+        import re
+
+        # Assert variables - These variable's name|format must be followed
+        # if you want to use the wrapper function
+        assert main, "There is no main"
+        assert main.CLIs, "There is no main.CLIs"
+        assert main.Mininet1, "Mininet handle should be named Mininet1"
+        assert main.numSwitch, "Placed the total number of switch topology in \
+                                main.numSwitch"
+
+        main.testName = "Point Intents"
+        main.case( main.testName + " Test - " + str( main.numCtrls ) +
+                   " NODE(S) - OF " + main.OFProtocol )
+        main.caseExplanation = "This test case will test point to point" +\
+                               " intents using " + str( main.numCtrls ) +\
+                               " node(s) cluster;\n" +\
+                               "Different type of hosts will be tested in " +\
+                               "each step such as IPV4, Dual stack, VLAN etc" +\
+                               ";\nThe test will use OF " + main.OFProtocol +\
+                               " OVS running in Mininet"
+
+        # No option point intents
+        main.step( "NOOPTION: Add point intents between h1 and h9, ipv6 hosts" )
+        main.assertReturnString = "Assertion Result for NOOPTION point intent\n"
+        stepResult = main.TRUE
+        stepResult = main.intentFunction.pointIntent(
+                                       main,
+                                       name="NOOPTION",
+                                       host1="h1",
+                                       host2="h9",
+                                       deviceId1="of:0000000000000005/1",
+                                       deviceId2="of:0000000000000006/1")
+
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass=main.assertReturnString,
+                                 onfail=main.assertReturnString )
+
+        stepResult = main.TRUE
+        main.step( "IPV6: Add point intents between h1 and h9" )
+        main.assertReturnString = "Assertion Result for IPV6 point intent\n"
+        stepResult = main.intentFunction.pointIntent(
+                                       main,
+                                       name="IPV6",
+                                       host1="h1",
+                                       host2="h9",
+                                       deviceId1="of:0000000000000005/1",
+                                       deviceId2="of:0000000000000006/1",
+                                       port1="1",
+                                       port2="1",
+                                       ethType="IPV6",
+                                       mac1="00:00:00:00:00:01",
+                                       mac2="00:00:00:00:00:09",
+                                       bandwidth="30",
+                                       lambdaAlloc=False,
+                                       ipProto="58",
+                                       ip1="10:1:0::1/128",
+                                       ip2="10:1:0::5/128",
+                                       tcp1="",
+                                       tcp2="",
+                                       expectedLink=18 )
+
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass=main.assertReturnString,
+                                 onfail=main.assertReturnString )
+
+        main.step( "IPV6_2: Add point intents between h1 and h9" )
+        main.assertReturnString = "Assertion Result for IPV6 no mac address point intents\n"
+        stepResult = main.intentFunction.pointIntent(
+                                       main,
+                                       name="IPV6_2",
+                                       host1="h1",
+                                       host2="h9",
+                                       deviceId1="of:0000000000000005/1",
+                                       deviceId2="of:0000000000000006/1",
+                                       ipProto="58",
+                                       ip1="10:1:0::1/128",
+                                       ip2="10:1:0::5/128",
+                                       tcp1="",
+                                       tcp2="",
+                                       expectedLink=18 )
+
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass=main.assertReturnString,
+                                 onfail=main.assertReturnString )
+        """
+        main.step( "SDNIP-ICMP: Add point intents between h1 and h9" )
+        main.assertReturnString = "Assertion Result for SDNIP-ICMP IPV4 using TCP point intents\n"
+        mac1 = main.hostsData[ 'h1' ][ 'mac' ]
+        mac2 = main.hostsData[ 'h9' ][ 'mac' ]
+        main.log.debug(mac2)
+
+        # TODO : Fix is IPv6 arg format
+        # when we install the intent "add-point-intent --ethType IPV6 --ethSrc 00:00:00:00:00:01 
+        # --ethDst 00:00:00:00:00:09 --ipProto 1 --ipSrc 10:1::1/128 --ipDst 10:1::5/128 
+        # of:0000000000000005/1 of:0000000000000006/1" controller reports following error :
+        # Malformed IP prefix string: 10:1::1. Address must take form "x.x.x.x/y" or "xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx/y"
+        ip1 = main.Mininet1.getIPAddress( 'h1', proto='IPV6' )
+        ip2 = main.Mininet1.getIPAddress( 'h9', proto='IPV6')
+
+        ipProto = main.params[ 'SDNIP' ][ 'icmpProto' ]
+        # Uneccessary, not including this in the selectors
+        tcp1 = main.params[ 'SDNIP' ][ 'srcPort' ]
+        tcp2 = main.params[ 'SDNIP' ][ 'dstPort' ]
+
+        stepResult = main.intentFunction.pointIntent(
+                                           main,
+                                           name="SDNIP-ICMP",
+                                           host1="h1",
+                                           host2="h9",
+                                           deviceId1="of:0000000000000005/1",
+                                           deviceId2="of:0000000000000006/1",
+                                           mac1=mac1,
+                                           mac2=mac2,
+                                           ethType="IPV6",
+                                           ipProto=ipProto,
+                                           ip1=ip1,
+                                           ip2=ip2 )
+
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass=main.assertReturnString,
+                                 onfail=main.assertReturnString )
+        
+        main.step( "SDNIP-TCP: Add point intents between h1 and h9" )
+        main.assertReturnString = "Assertion Result for SDNIP-TCP IPV4 using ICMP point intents\n"
+        mac1 = main.hostsData[ 'h1' ][ 'mac' ]
+        mac2 = main.hostsData[ 'h9' ][ 'mac' ]
+        ip1 = str( main.hostsData[ 'h1' ][ 'ipAddresses' ][ 0 ] ) + "/32"
+        ip2 = str( main.hostsData[ 'h9' ][ 'ipAddresses' ][ 0 ] ) + "/32"
+        ipProto = main.params[ 'SDNIP' ][ 'tcpProto' ]
+        tcp1 = main.params[ 'SDNIP' ][ 'srcPort' ]
+        tcp2 = main.params[ 'SDNIP' ][ 'dstPort' ]
+
+        stepResult = main.intentFunction.pointIntentTcp(
+                                           main,
+                                           name="SDNIP-TCP",
+                                           host1="h1",
+                                           host2="h9",
+                                           deviceId1="of:0000000000000005/1",
+                                           deviceId2="of:0000000000000006/1",
+                                           mac1=mac1,
+                                           mac2=mac2,
+                                           ethType="IPV4",
+                                           ipProto=ipProto,
+                                           ip1=ip1,
+                                           ip2=ip2,
+                                           tcp1=tcp1,
+                                           tcp2=tcp2 )
+
+        utilities.assert_equals( expect=main.TRUE,
+                             actual=stepResult,
+                                 onpass=main.assertReturnString,
+                                 onfail=main.assertReturnString )
+
+        main.step( "DUALSTACK1: Add point intents between h3 and h11" )
+        main.assertReturnString = "Assertion Result for Dualstack1 IPV4 with mac address point intents\n"
+        stepResult = main.intentFunction.pointIntent(
+                                       main,
+                                       name="DUALSTACK1",
+                                       host1="h3",
+                                       host2="h11",
+                                       deviceId1="of:0000000000000005",
+                                       deviceId2="of:0000000000000006",
+                                       port1="3",
+                                       port2="3",
+                                       ethType="IPV4",
+                                       mac1="00:00:00:00:00:03",
+                                       mac2="00:00:00:00:00:0B",
+                                       bandwidth="",
+                                       lambdaAlloc=False,
+                                       ipProto="",
+                                       ip1="",
+                                       ip2="",
+                                       tcp1="",
+                                       tcp2="",
+                                       sw1="s5",
+                                       sw2="s2",
+                                       expectedLink=18 )
+
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass=main.assertReturnString,
+                                 onfail=main.assertReturnString )
+
+        main.step( "VLAN: Add point intents between h5 and h21" )
+        main.assertReturnString = "Assertion Result for VLAN IPV4 with mac address point intents\n"
+        stepResult = main.intentFunction.pointIntent(
+                                       main,
+                                       name="VLAN",
+                                       host1="h5",
+                                       host2="h21",
+                                       deviceId1="of:0000000000000005/5",
+                                       deviceId2="of:0000000000000007/5",
+                                       port1="",
+                                       port2="",
+                                       ethType="IPV4",
+                                       mac1="00:00:00:00:00:05",
+                                       mac2="00:00:00:00:00:15",
+                                       bandwidth="",
+                                       lambdaAlloc=False,
+                                       ipProto="",
+                                       ip1="",
+                                       ip2="",
+                                       tcp1="",
+                                       tcp2="",
+                                       sw1="s5",
+                                       sw2="s2",
+                                       expectedLink=18 )
+
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass=main.assertReturnString,
+                                 onfail=main.assertReturnString )
+        """
+        main.step( "1HOP: Add point intents between h1 and h9" )
+        main.assertReturnString = "Assertion Result for 1HOP IPV6 with no mac address point intents\n"
+        stepResult = main.intentFunction.hostIntent( main,
+                                              name='1HOP',
+                                              host1='h1',
+                                              host2='h9',
+                                              host1Id='00:00:00:00:00:01/-1',
+                                              host2Id='00:00:00:00:00:09/-1')
+
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=stepResult,
+                                 onpass=main.assertReturnString,
+                                 onfail=main.assertReturnString )
+
+        main.intentFunction.report( main )
+"""
diff --git a/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.topo b/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.topo
index 617e8c0..3c8ae7c 100755
--- a/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.topo
+++ b/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.topo
@@ -3,8 +3,8 @@
 
         <ONOSbench>
             <host>localhost</host>
-            <user>admin</user>
-            <password></password>
+            <user>cnlabs</user>
+            <password>cnlabs123</password>
             <type>OnosDriver</type>
             <connect_order>1</connect_order>
             <COMPONENTS>
@@ -14,8 +14,8 @@
 
         <ONOScli1>
             <host>localhost</host>
-            <user>admin</user>
-            <password></password>
+            <user>cnlabs</user>
+            <password>cnlabs123</password>
             <type>OnosCliDriver</type>
             <connect_order>2</connect_order>
             <COMPONENTS> </COMPONENTS>
@@ -23,8 +23,8 @@
 
         <ONOScli2>
             <host>localhost</host>
-            <user>admin</user>
-            <password></password>
+            <user>cnlabs</user>
+            <password>cnlabs123</password>
             <type>OnosCliDriver</type>
             <connect_order>3</connect_order>
             <COMPONENTS> </COMPONENTS>
@@ -32,21 +32,31 @@
 
          <ONOScli3>
             <host>localhost</host>
-            <user>admin</user>
-            <password></password>
+            <user>cnlabs</user>
+            <password>cnlabs123</password>
             <type>OnosCliDriver</type>
             <connect_order>4</connect_order>
             <COMPONENTS> </COMPONENTS>
         </ONOScli3>
 
+        <ONOS1>
+            <host>OC1</host>
+            <user>cnlabs</user>
+            <password>cnlabs123</password>
+            <type>OnosDriver</type>
+            <connect_order>5</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOS1>
+
         <Mininet1>
             <host>OCN</host>
-            <user>admin</user>
-            <password></password>
+            <user>cnlabs</user>
+            <password>cnlabs123</password>
             <type>MininetCliDriver</type>
-            <connect_order>5</connect_order>
+            <connect_order>6</connect_order>
             <COMPONENTS>
                 <home>~/mininet/custom/</home>
+                <controller> remote </controller>
             </COMPONENTS>
         </Mininet1>
 
diff --git a/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.topo.save b/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.topo.save
new file mode 100755
index 0000000..fb4776d
--- /dev/null
+++ b/TestON/tests/FUNCipv6Intent/FUNCipv6Intent.topo.save
@@ -0,0 +1,64 @@
+<TOPOLOGY>
+    <COMPONENT>
+
+        <ONOSbench>
+            <host>localhost</host>
+            <user>cnlabs</user>
+            <password>cnlabs123</password>
+            <type>OnosDriver</type>
+            <connect_order>1</connect_order>
+            <COMPONENTS>
+                <nodes>3</nodes>
+            </COMPONENTS>
+        </ONOSbench>
+
+        <ONOScli1>
+            <host>localhost</host>
+            <user>cnlabs</user>
+            <password>cnlabs123</password>
+            <type>OnosCliDriver</type>
+            <connect_order>2</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOScli1>
+
+        <ONOScli2>
+            <host>localhost</host>
+            <user>cnlabs</user>
+            <password>cnlabs123</password>
+            <type>OnosCliDriver</type>
+            <connect_order>3</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOScli2>
+
+         <ONOScli3>
+            <host>localhost</host>
+            <user>cnlabs</user>
+            <password>cnlabs123</password>
+            <type>OnosCliDriver</type>
+            <connect_order>4</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOScli3>
+
+        <ONOS1>
+            <host>192.168.2.51</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>OnosDriver</type>
+            <connect_order>5</connect_order>
+            <COMPONENTS> </COMPONENTS>
+        </ONOS1>
+
+        <Mininet1>
+            <host>localhost</host>
+            <user>cnlabs</user>
+            <password>cnlabs123</password>
+            <type>MininetCliDriver</type>
+            <connect_order>6</connect_order>
+            <COMPONENTS>
+                <home>~/mininet/custom/</home>
+                <arg1>--topo 
+            </COMPONENTS>
+        </Mininet1>
+
+    </COMPONENT>
+</TOPOLOGY>