diff --git a/TestON/tests/USECASE/SegmentRouting/SRRouting/SRRouting.py b/TestON/tests/USECASE/SegmentRouting/SRRouting/SRRouting.py
index 150d7fd..281e7a5 100644
--- a/TestON/tests/USECASE/SegmentRouting/SRRouting/SRRouting.py
+++ b/TestON/tests/USECASE/SegmentRouting/SRRouting/SRRouting.py
@@ -1298,39 +1298,38 @@
         main.Cluster.active( 0 ).CLI.balanceMasters()
         time.sleep( float( main.params[ 'timers' ][ 'balanceMasterSleep' ] ) )
         verify( main )
-
+        # Move an untagged IPv4 host on DAAS-1
         h1v4cfg = '{"of:0000000000000001/7" : { "interfaces" : [ { "ips" : [ "10.1.0.254/24" ], "vlan-untagged": 10 } ] } }'
         lib.moveHost( main, "h1v4", "leaf1", "leaf1", "10.1.0.254", prefixLen=24, cfg=h1v4cfg )
         hostLocations = { "h1v4": "of:0000000000000001/7" }
         lib.verifyHostLocations( main, hostLocations )
         verify( main )
-
+        # Move an untagged IPv6 host on DAAS-1
         h1v6cfg = '{"of:0000000000000001/8" : { "interfaces" : [ { "ips" : [ "1000::3ff/120" ], "vlan-untagged": 21 } ] } }'
         lib.moveHost( main, "h1v6", "leaf1", "leaf1", "1000::3ff", prefixLen=128, cfg=h1v6cfg, ipv6=True )
         hostLocations = { "h1v6": "of:0000000000000001/8" }
         lib.verifyHostLocations( main, hostLocations )
         verify( main )
-
         # FIXME: We don't have any tagged hosts on DAAS-1
 
+        # Move an untagged IPv4 host on DAAS-2
         h13v4cfg = '{"of:0000000000000006/7" : { "interfaces" : [ { "ips" : [ "10.5.20.254/24" ], "vlan-untagged": 20 } ] } }'
         lib.moveHost( main, "h13v4", "leaf6", "leaf6", "10.5.20.254", prefixLen=24, cfg=h13v4cfg )
         hostLocations = { "h13v4": "of:0000000000000006/7" }
         lib.verifyHostLocations( main, hostLocations )
         verify( main )
-
+        # Move an untagged IPv6 host on DAAS-2
         h13v6cfg = '{"of:0000000000000006/8" : { "interfaces" : [ { "ips" : [ "1012::3ff/120" ], "vlan-untagged": 26 } ] } }'
         lib.moveHost( main, "h13v6", "leaf6", "leaf6", "1012::3ff", prefixLen=128, cfg=h13v6cfg, ipv6=True )
         hostLocations = { "h13v6": "of:0000000000000006/8" }
         lib.verifyHostLocations( main, hostLocations )
         verify( main )
-
+        # Move a tagged IPv4 host on DAAS-2
         h12v4cfg = '{"of:0000000000000006/9" : { "interfaces" : [ { "ips" : [ "10.5.10.254/24" ], "vlan-tagged": [80] } ] } }'
         lib.moveHost( main, "h12v4", "leaf6", "leaf6", "10.5.10.254", prefixLen=24, cfg=h12v4cfg, vlan=80 )
         hostLocations = { "h12v4": "of:0000000000000006/9" }
         lib.verifyHostLocations( main, hostLocations )
         verify( main )
-
         # FIXME: Due to CORD-3079, we are not able to test movement of tagged IPv6 hosts at the moment
         '''
         h12v6cfg = '{"of:0000000000000006/10" : { "interfaces" : [ { "ips" : [ "1011::3ff/120" ], "vlan-tagged": [127] } ] } }'
@@ -1357,28 +1356,42 @@
         time.sleep( float( main.params[ 'timers' ][ 'balanceMasterSleep' ] ) )
         verify( main )
 
+        # Move an untagged IPv4 host
+        lib.addStaticOnosRoute( main, "10.2.31.0/24", "10.2.30.1" )
+        lib.startScapyHosts( main, scapyNames=[ 'h4v4Scapy' ], mininetNames=[ 'h4v4' ] )
+        lib.verifyTraffic( main, main.internalIpv4Hosts, "10.2.31.1", "h4v4Scapy", "h4v4-bond0" )
         h4v4cfg = '''{"of:0000000000000002/12" : { "interfaces" : [ { "ips" : [ "10.2.30.254/24" ], "vlan-untagged": 16 } ] },
                       "of:0000000000000003/14" : { "interfaces" : [ { "ips" : [ "10.2.30.254/24" ], "vlan-untagged": 16 } ] } }'''
         lib.moveDualHomedHost( main, "h4v4", "leaf2", "leaf3", "leaf2", "leaf3", "10.2.30.254", prefixLen=24, cfg=h4v4cfg )
         hostLocations = { "h4v4": [ "of:0000000000000002/12", "of:0000000000000003/14" ] }
         lib.verifyHostLocations( main, hostLocations )
         verify( main )
+        lib.verifyTraffic( main, main.internalIpv4Hosts, "10.2.31.1", "h4v4Scapy", "h4v4-bond1" )
 
+        # Move an untagged IPv6 host
+        lib.addStaticOnosRoute( main, "1003::400/120", "1003::3fe" )
+        lib.startScapyHosts( main, scapyNames=[ 'h4v6Scapy' ], mininetNames=[ 'h4v6' ] )
+        lib.verifyTraffic( main, main.internalIpv6Hosts, "1003::4fe", "h4v6Scapy", "h4v6-bond0", ipv6=True )
         h4v6cfg = '''{"of:0000000000000002/13" : { "interfaces" : [ { "ips" : [ "1003::3ff/120" ], "vlan-untagged": 24 } ] },
                       "of:0000000000000003/15" : { "interfaces" : [ { "ips" : [ "1003::3ff/120" ], "vlan-untagged": 24 } ] } }'''
         lib.moveDualHomedHost( main, "h4v6", "leaf2", "leaf3", "leaf2", "leaf3", "1003::3fe", prefixLen=128, cfg=h4v6cfg, ipv6=True )
         hostLocations = { "h4v6": [ "of:0000000000000002/13", "of:0000000000000003/15" ] }
         lib.verifyHostLocations( main, hostLocations )
         verify( main )
+        lib.verifyTraffic( main, main.internalIpv6Hosts, "1003::4fe", "h4v6Scapy", "h4v6-bond1", ipv6=True )
 
+        # Move a tagged IPv4 host
+        lib.addStaticOnosRoute( main, "10.2.21.0/24", "10.2.20.1" )
+        lib.startScapyHosts( main, scapyNames=[ 'h5v4Scapy' ], mininetNames=[ 'h5v4' ] )
+        lib.verifyTraffic( main, main.internalIpv4Hosts, "10.2.21.1", "h5v4Scapy", "h5v4-bond0" )
         h5v4cfg = '''{"of:0000000000000002/14" : { "interfaces" : [ { "ips" : [ "10.2.20.254/24" ], "vlan-tagged": [30] } ] },
                       "of:0000000000000003/16" : { "interfaces" : [ { "ips" : [ "10.2.20.254/24" ], "vlan-tagged": [30] } ] } }'''
         lib.moveDualHomedHost( main, "h5v4", "leaf2", "leaf3", "leaf2", "leaf3", "10.2.20.254", prefixLen=24, cfg=h5v4cfg, vlan=30 )
         hostLocations = { "h5v4": [ "of:0000000000000002/14", "of:0000000000000003/16" ] }
         lib.verifyHostLocations( main, hostLocations )
         verify( main )
+        lib.verifyTraffic( main, main.internalIpv4Hosts, "10.2.21.1", "h5v4Scapy", "h5v4-bond1" )
 
-        # TODO: test static routes that point to the moved host
         lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )
 
     def CASE653( self, main ):
@@ -1396,26 +1409,40 @@
         time.sleep( float( main.params[ 'timers' ][ 'balanceMasterSleep' ] ) )
         verify( main )
 
+        # Move an untagged IPv4 host
+        lib.addStaticOnosRoute( main, "10.2.31.0/24", "10.2.30.1" )
+        lib.startScapyHosts( main, scapyNames=[ 'h4v4Scapy' ], mininetNames=[ 'h4v4' ] )
+        lib.verifyTraffic( main, main.internalIpv4Hosts, "10.2.31.1", "h4v4Scapy", "h4v4-bond0" )
         h4v4cfg = '''{"of:0000000000000002/12" : { "interfaces" : [ { "ips" : [ "10.2.30.254/24" ], "vlan-untagged": 16 } ] },
                       "of:0000000000000003/14" : { "interfaces" : [ { "ips" : [ "10.2.30.254/24" ], "vlan-untagged": 16 } ] } }'''
         lib.moveDualHomedHost( main, "h4v4", "leaf2", "leaf3", "leaf2", "leaf3", "10.2.30.254", macAddr="00:aa:01:00:00:03", prefixLen=24, cfg=h4v4cfg )
         hostLocations = { "h4v4": [ "of:0000000000000002/12", "of:0000000000000003/14" ] }
         lib.verifyHostLocations( main, hostLocations )
         verify( main )
+        lib.verifyTraffic( main, main.internalIpv4Hosts, "10.2.31.1", "h4v4Scapy", "h4v4-bond1" )
 
+        # Move an untagged IPv6 host
+        lib.addStaticOnosRoute( main, "1003::400/120", "1003::3fe" )
+        lib.startScapyHosts( main, scapyNames=[ 'h4v6Scapy' ], mininetNames=[ 'h4v6' ] )
+        lib.verifyTraffic( main, main.internalIpv6Hosts, "1003::4fe", "h4v6Scapy", "h4v6-bond0", ipv6=True )
         h4v6cfg = '''{"of:0000000000000002/13" : { "interfaces" : [ { "ips" : [ "1003::3ff/120" ], "vlan-untagged": 24 } ] },
                       "of:0000000000000003/15" : { "interfaces" : [ { "ips" : [ "1003::3ff/120" ], "vlan-untagged": 24 } ] } }'''
         lib.moveDualHomedHost( main, "h4v6", "leaf2", "leaf3", "leaf2", "leaf3", "1003::3fe", macAddr="00:bb:01:00:00:03", prefixLen=128, cfg=h4v6cfg, ipv6=True )
         hostLocations = { "h4v6": [ "of:0000000000000002/13", "of:0000000000000003/15" ] }
         lib.verifyHostLocations( main, hostLocations )
         verify( main )
+        lib.verifyTraffic( main, main.internalIpv6Hosts, "1003::4fe", "h4v6Scapy", "h4v6-bond1", ipv6=True )
 
+        # Move a tagged IPv4 host
+        lib.addStaticOnosRoute( main, "10.2.21.0/24", "10.2.20.1" )
+        lib.startScapyHosts( main, scapyNames=[ 'h5v4Scapy' ], mininetNames=[ 'h5v4' ] )
+        lib.verifyTraffic( main, main.internalIpv4Hosts, "10.2.21.1", "h5v4Scapy", "h5v4-bond0" )
         h5v4cfg = '''{"of:0000000000000002/14" : { "interfaces" : [ { "ips" : [ "10.2.20.254/24" ], "vlan-tagged": [30] } ] },
                       "of:0000000000000003/16" : { "interfaces" : [ { "ips" : [ "10.2.20.254/24" ], "vlan-tagged": [30] } ] } }'''
         lib.moveDualHomedHost( main, "h5v4", "leaf2", "leaf3", "leaf2", "leaf3", "10.2.20.254", macAddr="00:aa:01:00:00:04", prefixLen=24, cfg=h5v4cfg, vlan=30 )
         hostLocations = { "h5v4": [ "of:0000000000000002/14", "of:0000000000000003/16" ] }
         lib.verifyHostLocations( main, hostLocations )
         verify( main )
+        lib.verifyTraffic( main, main.internalIpv4Hosts, "10.2.21.1", "h5v4Scapy", "h5v4-bond1" )
 
-        # TODO: test static routes that point to the moved host
         lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )
diff --git a/TestON/tests/USECASE/SegmentRouting/SRRouting/SRRouting.topo b/TestON/tests/USECASE/SegmentRouting/SRRouting/SRRouting.topo
index dbb415d..fd61ee9 100644
--- a/TestON/tests/USECASE/SegmentRouting/SRRouting/SRRouting.topo
+++ b/TestON/tests/USECASE/SegmentRouting/SRRouting/SRRouting.topo
@@ -32,5 +32,15 @@
             </COMPONENTS>
         </Mininet1>
 
+        <Scapy>
+            <host>OCN</host>
+            <user>sdn</user>
+            <password>rocks</password>
+            <type>MininetScapyCliDriver</type>
+            <connect_order>3</connect_order>
+            <COMPONENTS>
+                <prompt></prompt>
+            </COMPONENTS>
+        </Scapy>
     </COMPONENT>
 </TOPOLOGY>
diff --git a/TestON/tests/USECASE/SegmentRouting/dependencies/Testcaselib.py b/TestON/tests/USECASE/SegmentRouting/dependencies/Testcaselib.py
index 8c6e22a..5bd3bdd 100644
--- a/TestON/tests/USECASE/SegmentRouting/dependencies/Testcaselib.py
+++ b/TestON/tests/USECASE/SegmentRouting/dependencies/Testcaselib.py
@@ -1102,23 +1102,71 @@
         main.Cluster.active( 0 ).REST.setNetCfg( json.loads( json.dumps( cfg ) ) )
 
     @staticmethod
-    def startScapyHosts( main ):
+    def startScapyHosts( main, scapyNames=[], mininetNames=[] ):
         """
         Create host components and start Scapy CLIs
+        scapyNames: list of names that will be used as component names for scapy hosts
+        mininetNames: used when scapy host names are different from the host names
+        in Mininet. E.g. when scapyNames=['h1Scapy'], it's required to specify the
+        name of the corresponding Mininet host by mininetNames=['h1']
         """
         main.step( "Start Scapy CLIs" )
-        main.scapyHostNames = main.params[ 'SCAPY' ][ 'HOSTNAMES' ].split( ',' )
+        if scapyNames:
+            main.scapyNames = scapyNames
+        else:
+            main.scapyNames = main.params[ 'SCAPY' ][ 'HOSTNAMES' ].split( ',' )
         main.scapyHosts = []
-        for hostName in main.scapyHostNames:
-            main.Scapy.createHostComponent( hostName )
-            main.scapyHosts.append( getattr( main, hostName ) )
-        for host in main.scapyHosts:
-            host.startHostCli()
-            host.startScapy()
-            host.updateSelf()
-            main.log.debug( host.name )
-            main.log.debug( host.hostIp )
-            main.log.debug( host.hostMac )
+        for scapyName in main.scapyNames:
+            main.Scapy.createHostComponent( scapyName )
+            scapyHandle = getattr( main, scapyName )
+            main.scapyHosts.append( scapyHandle )
+            if mininetNames:
+                mininetName = mininetNames[ scapyNames.index( scapyName ) ]
+            else:
+                mininetName = None
+            scapyHandle.startHostCli( mininetName )
+            scapyHandle.startScapy()
+            scapyHandle.updateSelf()
+            main.log.debug( scapyHandle.name )
+            main.log.debug( scapyHandle.hostIp )
+            main.log.debug( scapyHandle.hostMac )
+
+    @staticmethod
+    def verifyTraffic( main, srcHosts, dstIp, dstHost, dstIntf, ipv6=False, expect=True, skipOnFail=True, maxRetry=2 ):
+        """
+        Verify unicast traffic by pinging from source hosts to the destination IP
+        and capturing the packets at the destination host using Scapy.
+        srcHosts: List of host names to send the ping packets
+        dstIp: destination IP of the ping packets
+        dstHost: host that runs Scapy to capture the packets
+        dstIntf: name of the interface on the destination host
+        expect: use True if the ping is expected to be captured at destination;
+                Otherwise False
+        skipOnFail: skip the rest of this test case if result is not expected
+        maxRetry: number of retries allowed
+        """
+        from tests.dependencies.topology import Topology
+        try:
+            main.topo
+        except ( NameError, AttributeError ):
+            main.topo = Topology()
+        main.step( "Verify traffic to {} by capturing packets on {}".format( dstIp, dstHost ) )
+        result = main.TRUE
+        for srcHost in srcHosts:
+            trafficResult = main.topo.pingAndCapture( srcHost, dstIp, dstHost, dstIntf, ipv6,
+                                                      expect, maxRetry, True )
+            if not trafficResult:
+                main.stop()
+                result = main.FALSE
+                main.log.warn( "Scapy result from {} to {} is not as expected".format( srcHost, dstIp ) )
+        utilities.assert_equals( expect=main.TRUE,
+                                 actual=result,
+                                 onpass="Verify traffic to {}: Pass".format( dstIp ),
+                                 onfail="Verify traffic to {}: Fail".format( dstIp ) )
+        if skipOnFail and result != main.TRUE:
+            Testcaselib.saveOnosDiagnostics( main )
+            Testcaselib.cleanup( main, copyKarafLog=False )
+            main.skipCase()
 
     @staticmethod
     def verifyMulticastTraffic( main, routeName, expect, skipOnFail=True, maxRetry=1 ):