TestON/tests/USECASE/SegmentRouting/SRRouting/SRRouting.py

class SRRouting:

    def __init__( self ):
        self.default = ''

    def CASE1( self, main ):
        """
        Ping between all ipv4 hosts in the topology.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Ping between all ipv4 hosts in the topology" )
        setupTest( main, test_idx=1, onosNodes=3, ipv6=False, external=False )
        verify( main, ipv6=False, disconnected=False, external=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE2( self, main ):
        """
        Ping between all ipv6 hosts in the topology.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Ping between all ipv6 hosts in the topology" )
        setupTest( main, test_idx=2, onosNodes=3, ipv4=False, external=False )
        verify( main, ipv4=False, disconnected=False, external=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE3( self, main ):
        """
        Ping between all ipv4 and ipv6 hosts in the topology.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Ping between all ipv4 and ipv6 hosts in the topology" )
        setupTest( main, test_idx=3, onosNodes=3, external=False )
        verify( main, disconnected=False, external=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE4( self, main ):
        """
        Ping between all ipv4 hosts in the topology and check connectivity to external ipv4 hosts
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Ping between all ipv4 hosts in the topology and check connectivity to external ipv4 hosts" )
        setupTest( main, test_idx=4, onosNodes=3, ipv6=False )
        verify( main, ipv6=False, disconnected=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE5( self, main ):
        """
        Ping between all ipv6 hosts in the topology and check connectivity to external ipv6 hosts
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Ping between all ipv6 hosts in the topology and check connectivity to external ipv6 hosts" )
        setupTest( main, test_idx=5, onosNodes=3, ipv4=False )
        verify( main, ipv4=False, disconnected=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE6( self, main ):
        """
        Ping between all ipv4 and ipv6 hosts in the topology and check connectivity to external ipv4 and ipv6 hosts
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Ping between all ipv4 and ipv6 hosts in the topology and check connectivity to external hosts" )
        setupTest( main, test_idx=6, onosNodes=3 )
        verify( main, disconnected=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE7( self, main ):
        """
        Ping between ipv4 hosts and an external host that is not configured in
        external router config, but reachable through the use of route-add
        command.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Ping between from ipv4 hosts to external host configured with route-add command" )
        setupTest( main, test_idx=7, onosNodes=3, ipv6=False, external=False )
        verify( main, ipv6=False, internal=False, disconnected=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE8( self, main ):
        """
        Ping between ipv6 hosts and an external host that is not configured in
        external router config, but reachable through the use of route-add
        command.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Ping between from ipv6 hosts to external host configured with route-add command" )
        setupTest( main, test_idx=8, onosNodes=3, ipv4=False, external=False )
        verify( main, ipv6=False, internal=False, disconnected=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE9( self, main ):
        """
        Ping between ipv4 and pv6 hosts and external hosts that is not configured in
        external router config, but reachable through the use of route-add
        command.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Ping between from ipv4 and ipv6 hosts to external host configured with route-add command" )
        setupTest( main, test_idx=9, onosNodes=3, external=False )
        verify( main, internal=False, disconnected=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE101( self, main ):
        """
        Kill and recover links
        Ping between all ipv4 hosts in the topology.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test link failures with IPv4 hosts" )
        setupTest( main, test_idx=101, onosNodes=3, ipv6=False, external=False )
        verify( main, ipv6=False, external=False, disconnected=False )
        verifyLinkFailure( main, ipv6=False, external=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE102( self, main ):
        """
        Kill and recover links
        Ping between all ipv6 hosts in the topology.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test link failures with IPv6 hosts" )
        setupTest( main, test_idx=102, onosNodes=3, ipv4=False, external=False )
        verify( main, ipv4=False, external=False, disconnected=False )
        verifyLinkFailure( main, ipv4=False, external=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE103( self, main ):
        """
        Kill and recover links
        Ping between all ipv4 and ipv6 hosts in the topology.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test link failures with IPv4 and IPv6 hosts" )
        setupTest( main, test_idx=103, onosNodes=3, external=False )
        verify( main, external=False, disconnected=False )
        verifyLinkFailure( main, external=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE104( self, main ):
        """
        Kill and recover links
        Ping between all ipv4 hosts in the topology and check connectivity to external ipv4 hosts
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test link failures with IPv4 hosts including external hosts" )
        setupTest( main, test_idx=104, onosNodes=3, ipv6=False )
        verify( main, ipv6=False, disconnected=False )
        verifyLinkFailure( main, ipv6=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE105( self, main ):
        """
        Kill and recover links
        Ping between all ipv6 hosts in the topology and check connectivity to external ipv6 hosts
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test link failures with IPv6 hosts including external hosts" )
        setupTest( main, test_idx=105, onosNodes=3, ipv4=False )
        verify( main, ipv4=False, disconnected=False )
        verifyLinkFailure( main, ipv4=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE106( self, main ):
        """
        Kill and recover links
        Ping between all ipv4 and ipv6 hosts in the topology and check connectivity to external ipv4 and ipv6 hosts
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test link failures with IPv4 and IPv6 hosts including external hosts" )
        setupTest( main, test_idx=106, onosNodes=3 )
        verify( main, disconnected=False )
        verifyLinkFailure( main )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE107( self, main ):
        """
        Kill and recover links
        Ping between ipv4 hosts and an external host that is not configured in
        external router config, but reachable through the use of route-add command.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test link failures with IPv4 hosts including external hosts configured with route-add command" )
        setupTest( main, test_idx=107, onosNodes=3, ipv6=False, external=False )
        verify( main, ipv6=False, disconnected=False )
        verifyLinkFailure( main, ipv6=False, internal=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE108( self, main ):
        """
        Kill and recover links
        Ping between ipv6 hosts and an external host that is not configured in
        external router config, but reachable through the use of route-add command.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test link failures with IPv6 hosts including external hosts configured with route-add command" )
        setupTest( main, test_idx=108, onosNodes=3, ipv4=False, external=False )
        verify( main, ipv4=False, disconnected=False )
        verifyLinkFailure( main, ipv4=False, internal=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE109( self, main ):
        """
        Kill and recover links
        Ping between ipv4 and pv6 hosts and external hosts that is not configured in
        external router config, but reachable through the use of route-add command.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test link failures with IPv4 and IPv6 hosts including external hosts configured with route-add command" )
        setupTest( main, test_idx=109, onosNodes=3, external=False )
        verify( main, disconnected=False )
        verifyLinkFailure( main, internal=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE201( self, main ):
        """
        Kill and recover spine switches
        Ping between all ipv4 hosts in the topology.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test switch failures with IPv4 hosts" )
        setupTest( main, test_idx=201, onosNodes=3, ipv6=False, external=False )
        verify( main, ipv6=False, external=False, disconnected=False )
        verifySwitchFailure( main, ipv6=False, external=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE202( self, main ):
        """
        Kill and recover spine switches
        Ping between all ipv6 hosts in the topology.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test switch failures with IPv6 hosts" )
        setupTest( main, test_idx=202, onosNodes=3, ipv4=False, external=False )
        verify( main, ipv4=False, external=False, disconnected=False )
        verifySwitchFailure( main, ipv4=False, external=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE203( self, main ):
        """
        Kill and recover spine switches
        Ping between all ipv4 and ipv6 hosts in the topology.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test switch failures with IPv4 and IPv6 hosts" )
        setupTest( main, test_idx=203, onosNodes=3, external=False )
        verify( main, external=False, disconnected=False )
        verifySwitchFailure( main, external=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE204( self, main ):
        """
        Kill and recover spine switches
        Ping between all ipv4 hosts in the topology and check connectivity to external ipv4 hosts
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test switch failures with IPv4 hosts including external hosts" )
        setupTest( main, test_idx=204, onosNodes=3, ipv6=False )
        verify( main, ipv6=False, disconnected=False )
        verifySwitchFailure( main, ipv6=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE205( self, main ):
        """
        Kill and recover spine switches
        Ping between all ipv6 hosts in the topology and check connectivity to external ipv6 hosts
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test switch failures with IPv6 hosts including external hosts" )
        setupTest( main, test_idx=205, onosNodes=3, ipv4=False )
        verify( main, ipv4=False, disconnected=False )
        verifySwitchFailure( main, ipv4=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE206( self, main ):
        """
        Kill and recover spine switches
        Ping between all ipv4 and ipv6 hosts in the topology and check connectivity to external ipv4 and ipv6 hosts
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test switch failures with IPv4 and IPv6 hosts including external hosts" )
        setupTest( main, test_idx=206, onosNodes=3 )
        verify( main, disconnected=False )
        verifySwitchFailure( main )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE207( self, main ):
        """
        Kill and recover spine switches
        Ping between ipv4 hosts and an external host that is not configured in
        external router config, but reachable through the use of route-add command.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test switch failures with IPv4 hosts including external hosts configured with route-add command" )
        setupTest( main, test_idx=207, onosNodes=3, ipv6=False, external=False )
        verify( main, ipv6=False, disconnected=False )
        verifySwitchFailure( main, ipv6=False, internal=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE208( self, main ):
        """
        Kill and recover spine switches
        Ping between ipv6 hosts and an external host that is not configured in
        external router config, but reachable through the use of route-add command.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test switch failures with IPv6 hosts including external hosts configured with route-add command" )
        setupTest( main, test_idx=208, onosNodes=3, ipv4=False, external=False )
        verify( main, ipv4=False, disconnected=False )
        verifySwitchFailure( main, ipv4=False, internal=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE209( self, main ):
        """
        Kill and recover spine switches
        Ping between ipv4 and pv6 hosts and external hosts that is not configured in
        external router config, but reachable through the use of route-add command.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test switch failures with IPv4 and IPv6 hosts including external hosts configured with route-add command" )
        setupTest( main, test_idx=209, onosNodes=3, external=False )
        verify( main, disconnected=False )
        verifySwitchFailure( main, internal=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE301( self, main ):
        """
        Kill and recover onos nodes
        Ping between all ipv4 hosts in the topology.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test onos failures with IPv4 hosts" )
        setupTest( main, test_idx=301, onosNodes=3, ipv6=False, external=False )
        verify( main, ipv6=False, external=False, disconnected=False )
        verifyOnosFailure( main, ipv6=False, external=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE302( self, main ):
        """
        Kill and recover onos nodes
        Ping between all ipv6 hosts in the topology.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test onos failures with IPv6 hosts" )
        setupTest( main, test_idx=302, onosNodes=3, ipv4=False, external=False )
        verify( main, ipv4=False, external=False, disconnected=False )
        verifyOnosFailure( main, ipv4=False, external=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE303( self, main ):
        """
        Kill and recover onos nodes
        Ping between all ipv4 and ipv6 hosts in the topology.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test onos failures with IPv4 and IPv6 hosts" )
        setupTest( main, test_idx=303, onosNodes=3, external=False )
        verify( main, external=False, disconnected=False )
        verifyOnosFailure( main, external=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE304( self, main ):
        """
        Kill and recover onos nodes
        Ping between all ipv4 hosts in the topology and check connectivity to external ipv4 hosts
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test onos failures with IPv4 hosts including external hosts" )
        setupTest( main, test_idx=304, onosNodes=3, ipv6=False )
        verify( main, ipv6=False, disconnected=False )
        verifyOnosFailure( main, ipv6=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE305( self, main ):
        """
        Kill and recover onos nodes
        Ping between all ipv6 hosts in the topology and check connectivity to external ipv6 hosts
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test onos failures with IPv6 hosts including external hosts" )
        setupTest( main, test_idx=305, onosNodes=3, ipv4=False )
        verify( main, ipv4=False, disconnected=False )
        verifyOnosFailure( main, ipv4=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE306( self, main ):
        """
        Kill and recover onos nodes
        Ping between all ipv4 and ipv6 hosts in the topology and check connectivity to external ipv4 and ipv6 hosts
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test onos failures with IPv4 and IPv6 hosts including external hosts" )
        setupTest( main, test_idx=306, onosNodes=3 )
        verify( main, disconnected=False )
        verifyOnosFailure( main )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE307( self, main ):
        """
        Kill and recover onos nodes
        Ping between ipv4 hosts and an external host that is not configured in
        external router config, but reachable through the use of route-add command.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test onos failures with IPv4 hosts including external hosts configured with route-add command" )
        setupTest( main, test_idx=307, onosNodes=3, ipv6=False, external=False )
        verify( main, ipv6=False, disconnected=False )
        verifyOnosFailure( main, ipv6=False, internal=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE308( self, main ):
        """
        Kill and recover onos nodes
        Ping between ipv6 hosts and an external host that is not configured in
        external router config, but reachable through the use of route-add command.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test onos failures with IPv6 hosts including external hosts configured with route-add command" )
        setupTest( main, test_idx=308, onosNodes=3, ipv4=False, external=False )
        verify( main, ipv4=False, disconnected=False )
        verifyOnosFailure( main, ipv4=False, internal=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE309( self, main ):
        """
        Kill and recover onos nodes
        Ping between ipv4 and pv6 hosts and external hosts that is not configured in
        external router config, but reachable through the use of route-add command.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Test onos failures with IPv4 and IPv6 hosts including external hosts configured with route-add command" )
        setupTest( main, test_idx=309, onosNodes=3, external=False )
        verify( main, disconnected=False )
        verifyOnosFailure( main, internal=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE601( self, main ):
        """
        Bring down all switches
        Verify Topology
        Bring up all switches
        Verify

        repeat x3
        """
        import time
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Bring down all switches then recover" )
        setupTest( main, test_idx=601, external=False )
        main.Cluster.next().CLI.balanceMasters()
        time.sleep( float( main.params[ 'timers' ][ 'balanceMasterSleep' ] ) )
        main.Network.discoverHosts( hostList=main.internalIpv4Hosts + main.internalIpv6Hosts )
        totalSwitches = int( main.params[ 'TOPO' ][ 'switchNum' ] )
        totalLinks = int( main.params[ 'TOPO' ][ 'linkNum' ] )
        switchList = [ 'spine101', 'spine102', 'spine103', 'spine104',
                       'leaf1', 'leaf2', 'leaf3', 'leaf4', 'leaf5', 'leaf6' ]
        verify( main, disconnected=False, external=False )
        for i in range( 1, 4 ):
            main.log.info( "Beginning iteration {} of stopping then starting all switches".format( i ) )
            main.log.debug( main.Cluster.next().summary() )
            # Bring down all switches
            main.step( "Stopping switches - iteration " + str( i ) )
            switchStop = main.TRUE
            for switch in switchList:
                switchStop = switchStop and main.Network.switch( SW=switch, OPTION="stop" )
            utilities.assert_equals( expect=main.TRUE, actual=switchStop,
                                     onpass="All switches stopped",
                                     onfail="Failed to stop all switches" )

            time.sleep( 60 )
            lib.verifyTopology( main, 0, 0, main.Cluster.numCtrls )
            # Bring up all switches
            main.log.debug( main.Cluster.next().summary() )
            main.step( "Starting switches - iteration " + str( i ) )
            switchStart = main.TRUE
            for switch in switchList:
                switchStart = switchStart and main.Network.switch( SW=switch, OPTION="start" )
            utilities.assert_equals( expect=main.TRUE, actual=switchStart,
                                     onpass="All switches started",
                                     onfail="Failed to start all switches" )

            main.Network.discoverHosts( hostList=main.internalIpv4Hosts + main.internalIpv6Hosts )
            lib.verifyTopology( main, totalSwitches, totalLinks, main.Cluster.numCtrls )
            main.log.debug( main.Cluster.next().summary() )
            time.sleep( 60 )
            main.log.debug( main.Cluster.next().summary() )
            time.sleep( 60 )
            main.log.debug( main.Cluster.next().summary() )
            verifyPing( main )
            verify( main, disconnected=False, external=False )
        verify( main, disconnected=False, external=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE603( self, main ):
        """"
        Drop HAGG-1 device and test connectivity.
        Drop DAAS-1 device and test connectivity (some hosts lost it)
        Bring up DAAS-1 and test connectivity (all hosts gained it again)

        Repeat the same with HAGG-2 and DAAS-2.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Drop hagg spine switch along with dass leaf switch." )
        setupTest( main, test_idx=603, onosNodes=3 )
        main.disconnectedIpv4Hosts = []
        main.disconnectedIpv6Hosts = []

        verify( main )
        lib.killSwitch( main, "spine103",
                        int( main.params[ "TOPO" ]["switchNum" ] ) - 1,
                        int( main.params[ "TOPO" ][ "linkNum" ] ) - 6 )
        verify( main )
        lib.killSwitch( main, "leaf6",
                        int( main.params[ "TOPO" ]["switchNum" ] ) - 2,
                        int( main.params[ "TOPO" ][ "linkNum" ] ) - 8 )
        main.disconnectedIpv4Hosts = [ 'h12v4', 'h13v4']
        main.disconnectedIpv6Hosts = [ 'h12v6', 'h13v6']
        verify( main )
        lib.recoverSwitch( main, "leaf6",
                           int( main.params[ "TOPO" ]["switchNum" ] ) - 1,
                           int( main.params[ "TOPO" ][ "linkNum" ] ) - 6,
                           rediscoverHosts=True)
        main.disconnectedIpv4Hosts = []
        main.disconnectedIpv6Hosts = []
        verify( main )
        lib.recoverSwitch( main, "spine103",
                           int( main.params[ "TOPO" ][ "switchNum" ] ),
                           int( main.params[ "TOPO" ][ "linkNum" ] ) )
        verify( main )

        lib.killSwitch( main, "spine104",
                        int( main.params[ "TOPO" ]["switchNum" ] ) - 1,
                        int( main.params[ "TOPO" ][ "linkNum" ] ) - 6 )
        verify( main )
        lib.killSwitch( main, "leaf1",
                        int( main.params[ "TOPO" ]["switchNum" ] ) - 2,
                        int( main.params[ "TOPO" ][ "linkNum" ] ) - 8 )
        main.disconnectedIpv4Hosts = [ 'h1v4', 'h2v4']
        main.disconnectedIpv6Hosts = [ 'h1v6', 'h2v6']
        verify( main )
        lib.recoverSwitch( main, "leaf1",
                           int( main.params[ "TOPO" ]["switchNum" ] ) - 1,
                           int( main.params[ "TOPO" ][ "linkNum" ] ) - 6,
                           rediscoverHosts=True )
        main.disconnectedIpv4Hosts = []
        main.disconnectedIpv6Hosts = []
        verify( main )
        lib.recoverSwitch( main, "spine104",
                           int( main.params[ "TOPO" ][ "switchNum" ] ),
                           int( main.params[ "TOPO" ][ "linkNum" ] ) )
        verify( main )

        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE604( self, main ):
        """"
        Drop HAGG-1 device and test connectivity.
        Bring up HAGG-1 and test connectivity.
        Drop HAGG-2 device and test connectivity.
        Bring up HAGG-2 device and test connectivity
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Drop hagg spine switches." )
        setupTest( main, test_idx=604, onosNodes=3 )
        main.disconnectedIpv4Hosts = []
        main.disconnectedIpv6Hosts = []
        verify( main )
        lib.killSwitch( main, "spine103",
                        int( main.params[ "TOPO" ]["switchNum" ] ) - 1,
                        int( main.params[ "TOPO" ][ "linkNum" ] ) - 6 )
        verify( main )
        lib.recoverSwitch( main, "spine103",
                           int( main.params[ "TOPO" ][ "switchNum" ] ),
                           int( main.params[ "TOPO" ][ "linkNum" ] ) )
        verify( main )
        lib.killSwitch( main, "spine104",
                        int( main.params[ "TOPO" ]["switchNum" ] ) - 1,
                        int( main.params[ "TOPO" ][ "linkNum" ] ) - 6 )
        verify( main )
        lib.recoverSwitch( main, "spine104",
                           int( main.params[ "TOPO" ][ "switchNum" ] ),
                           int( main.params[ "TOPO" ][ "linkNum" ] ) )
        verify( main )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE605( self, main ):
        """
        Drop HAGG-1 and test connectivity (expect no failure)
        Drop all leafs in big fabric and test connectivity (expect some failures)
        Bring up HAGG-1 and test connectivity (still expect some failures)
        Bring up all leafs in big fabric and test connectivity (expect no failure)
        Repeat above with HAGG-2
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Drop one hagg and all leafs in big fabric" )
        setupTest( main, test_idx=605, onosNodes=3 )
        main.disconnectedIpv4Hosts = []
        main.disconnectedIpv6Hosts = []
        verify( main )
        lib.killSwitch( main, "spine103",
                        int( main.params[ "TOPO" ][ "switchNum" ] ) - 1,
                        int( main.params[ "TOPO" ][ "linkNum" ] ) - 6 )
        verify( main )
        lib.killSwitch( main, [ "leaf2", "leaf3", "leaf4", "leaf5" ],
                        int( main.params[ "TOPO" ][ "switchNum" ] ) - 5,
                        int( main.params[ "TOPO" ][ "linkNum" ] ) - 42 )
        main.disconnectedIpv4Hosts = [ "h3v4", "h4v4", "h5v4", "h6v4", "h7v4", "h8v4", "h9v4", "h10v4", "h11v4" ]
        main.disconnectedIpv6Hosts = [ "h3v6", "h4v6", "h5v6", "h6v6", "h7v6", "h8v6", "h9v6", "h10v6", "h11v6" ]
        main.disconnectedExternalIpv4Hosts = [ "rh1v4", "rh2v4", "rh5v4" ]
        main.disconnectedExternalIpv6Hosts = [ "rh1v6", "rh11v6", "rh5v6", "rh2v6", "rh22v6" ]
        verify( main, disconnected=True )
        lib.recoverSwitch( main, "spine103",
                           int( main.params[ "TOPO" ][ "switchNum" ] ) - 4,
                           int( main.params[ "TOPO" ][ "linkNum" ] ) - 36 )
        verify( main, disconnected=True )
        lib.recoverSwitch( main, [ "leaf2", "leaf3", "leaf4", "leaf5" ],
                           int( main.params[ "TOPO" ][ "switchNum" ] ),
                           int( main.params[ "TOPO" ][ "linkNum" ] ) )
        main.disconnectedIpv4Hosts = []
        main.disconnectedIpv6Hosts = []
        main.disconnectedExternalIpv4Hosts = [ ]
        main.disconnectedExternalIpv6Hosts = [ ]
        verify( main )

        lib.killSwitch( main, "spine104",
                        int( main.params[ "TOPO" ][ "switchNum" ] ) - 1,
                        int( main.params[ "TOPO" ][ "linkNum" ] ) - 6 )
        verify( main )
        lib.killSwitch( main, [ "leaf2", "leaf3", "leaf4", "leaf5" ],
                        int( main.params[ "TOPO" ][ "switchNum" ] ) - 5,
                        int( main.params[ "TOPO" ][ "linkNum" ] ) - 42 )
        main.disconnectedIpv4Hosts = [ "h3v4", "h4v4", "h5v4", "h6v4", "h7v4", "h8v4", "h9v4", "h10v4", "h11v4" ]
        main.disconnectedIpv6Hosts = [ "h3v6", "h4v6", "h5v6", "h6v6", "h7v6", "h8v6", "h9v6", "h10v6", "h11v6" ]
        main.disconnectedExternalIpv4Hosts = [ "rh1v4", "rh2v4", "rh5v4" ]
        main.disconnectedExternalIpv6Hosts = [ "rh1v6", "rh11v6", "rh5v6", "rh2v6", "rh22v6" ]
        verify( main, disconnected=True )
        lib.recoverSwitch( main, "spine104",
                           int( main.params[ "TOPO" ][ "switchNum" ] ) - 4,
                           int( main.params[ "TOPO" ][ "linkNum" ] ) - 36 )
        verify( main, disconnected=True )
        lib.recoverSwitch( main, [ "leaf2", "leaf3", "leaf4", "leaf5" ],
                           int( main.params[ "TOPO" ][ "switchNum" ] ),
                           int( main.params[ "TOPO" ][ "linkNum" ] ) )
        main.disconnectedIpv4Hosts = []
        main.disconnectedIpv6Hosts = []
        main.disconnectedExternalIpv4Hosts = [ ]
        main.disconnectedExternalIpv6Hosts = [ ]
        verify( main )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE606( self, main ):
        """
        Drop SPINE-1 and test connectivity
        Drop paired leaf and test connectivity (expect some failures)
        Bring up SPINE-1 and test connectivity (still expect some failures)
        Bring up the paired leaf and test connectivity
        Repeat above with SPINE-2 and a different paired leaf
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Drop spine and paired leaf" )
        setupTest( main, test_idx=606, onosNodes=3 )
        verify( main, disconnected=False )
        # Drop spine101 and leaf-2/3
        lib.killSwitch( main, "spine101", 9, 30 )
        verify( main, disconnected=False )
        lib.killSwitch( main, "leaf2", 8, 24 )
        lib.killSwitch( main, "leaf3", 7, 20 )
        main.disconnectedIpv4Hosts = [ "h3v4", "h4v4", "h5v4", "h6v4", "h7v4" ]
        main.disconnectedIpv6Hosts = [ "h3v6", "h4v6", "h5v6", "h6v6", "h7v6" ]
        verify( main )
        lib.recoverSwitch( main, "spine101", 8, 30 )
        verify( main )
        lib.recoverSwitch( main, "leaf3", 9, 38 )
        lib.recoverSwitch( main, "leaf2", 10, 48, rediscoverHosts=True,
                           hostsToDiscover=main.disconnectedIpv4Hosts + main.disconnectedIpv6Hosts )
        main.disconnectedIpv4Hosts = []
        main.disconnectedIpv6Hosts = []
        verify( main, disconnected=False )
        # Drop spine102 and leaf-4/5
        lib.killSwitch( main, "spine102", 9, 30 )
        verify( main, disconnected=False )
        lib.killSwitch( main, "leaf4", 8, 24 )
        lib.killSwitch( main, "leaf5", 7, 20 )
        main.disconnectedIpv4Hosts = [ "h8v4", "h9v4", "h10v4", "h11v4" ]
        main.disconnectedIpv6Hosts = [ "h8v6", "h9v6", "h10v6", "h11v6" ]
        verify( main, external=False )
        lib.recoverSwitch( main, "spine102", 8, 30 )
        verify( main, external=False )
        lib.recoverSwitch( main, "leaf5", 9, 38 )
        lib.recoverSwitch( main, "leaf4", 10, 48, rediscoverHosts=True,
                           hostsToDiscover=main.disconnectedIpv4Hosts + main.disconnectedIpv6Hosts )
        main.disconnectedIpv4Hosts = []
        main.disconnectedIpv6Hosts = []
        verify( main, disconnected=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE620( self, main ):
        """
        Take down one of double links towards the spine from all leaf switches and
        check that buckets in select groups change accordingly
        Bring up links again and check that buckets in select groups change accordingly
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Take down one of double links towards the spine" )
        setupTest( main, test_idx=620, onosNodes=3 )
        verify( main, disconnected=False )
        portsToDisable = [ [ "of:0000000000000002", 1 ], [ "of:0000000000000002", 3 ],
                           [ "of:0000000000000003", 1 ], [ "of:0000000000000003", 3 ],
                           [ "of:0000000000000004", 1 ], [ "of:0000000000000004", 3 ],
                           [ "of:0000000000000005", 1 ], [ "of:0000000000000005", 3 ] ]
        lib.disablePortBatch( main, portsToDisable, 10, 32 )
        # TODO: check buckets in groups
        verify( main, disconnected=False )
        lib.enablePortBatch( main, portsToDisable, 10, 48 )
        # TODO: check buckets in groups
        verify( main, disconnected=False )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE621( self, main ):
        """
        Remove all the links in the network and restore all Links (repeat x3)
        """
        import time
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Remove all the links in the network and restore all Links" )
        setupTest( main, test_idx=621, onosNodes=3 )
        verify( main, disconnected=False )
        linksToRemove = [ ["spine101", "spine103"], ["spine102", "spine104"],
                          ["spine103", "leaf6"], ["spine103", "leaf1"],
                          ["spine104", "leaf6"], ["spine104", "leaf1"],
                          ["spine101", "leaf2"], ["spine101", "leaf3"], ["spine101", "leaf4"], ["spine101", "leaf5"],
                          ["spine102", "leaf2"], ["spine102", "leaf3"], ["spine102", "leaf4"], ["spine102", "leaf5"],
                          ["leaf2", "leaf3"], ["leaf4", "leaf5"] ]
        portsToDisable = [ [ "of:0000000000000001", 3 ], [ "of:0000000000000001", 4 ],
                           [ "of:0000000000000001", 5 ], [ "of:0000000000000001", 6 ],
                           [ "of:0000000000000002", 6 ], [ "of:0000000000000002", 7 ],
                           [ "of:0000000000000002", 8 ], [ "of:0000000000000002", 9 ],
                           [ "of:0000000000000002", 10 ], [ "of:0000000000000002", 11 ],
                           [ "of:0000000000000003", 6 ], [ "of:0000000000000003", 7 ],
                           [ "of:0000000000000003", 8 ], [ "of:0000000000000003", 9 ],
                           [ "of:0000000000000003", 10 ], [ "of:0000000000000003", 11 ],
                           [ "of:0000000000000003", 12 ], [ "of:0000000000000003", 13 ],
                           [ "of:0000000000000004", 6 ], [ "of:0000000000000004", 7 ],
                           [ "of:0000000000000004", 8 ], [ "of:0000000000000004", 9 ],
                           [ "of:0000000000000004", 10 ], [ "of:0000000000000004", 11 ],
                           [ "of:0000000000000004", 12 ], [ "of:0000000000000004", 13 ], [ "of:0000000000000004", 14 ],
                           [ "of:0000000000000005", 6 ], [ "of:0000000000000005", 7 ],
                           [ "of:0000000000000005", 8 ], [ "of:0000000000000005", 9 ],
                           [ "of:0000000000000005", 10 ], [ "of:0000000000000005", 11 ],
                           [ "of:0000000000000005", 12 ], [ "of:0000000000000005", 13 ],
                           [ "of:0000000000000005", 14 ], [ "of:0000000000000005", 15 ],
                           [ "of:0000000000000006", 3 ], [ "of:0000000000000006", 4 ],
                           [ "of:0000000000000006", 5 ], [ "of:0000000000000006", 6 ] ]
        for i in range( 0, 3 ):
            lib.killLinkBatch( main, linksToRemove, 0, 10 )
            lib.disablePortBatch( main, portsToDisable, 10, 0 )
            main.disconnectedIpv4Hosts = main.internalIpv4Hosts
            main.disconnectedIpv6Hosts = main.internalIpv6Hosts
            verify( main )
            lib.restoreLinkBatch( main, linksToRemove, 48, 10 )
            lib.enablePortBatch( main, portsToDisable, 10, 48 )
            main.Network.discoverHosts( hostList=main.disconnectedIpv4Hosts + main.disconnectedIpv6Hosts )
            time.sleep( 10 )
            main.disconnectedIpv4Hosts = []
            main.disconnectedIpv6Hosts = []
            verify( main )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE622( self, main ):
        """
        Take down all uplinks from a paired leaf switch
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        from core import utilities
        main.case( "Take down all uplinks from a paired leaf switch" )
        setupTest( main, test_idx=622, onosNodes=3 )
        verify( main, disconnected=False )
        ctrl = main.Cluster.active( 0 )
        hostLocations = { "h4v6": [ "of:0000000000000002/7", "of:0000000000000003/6" ],
                          "h5v6": [ "of:0000000000000002/8", "of:0000000000000003/7" ],
                          "h4v4": [ "of:0000000000000002/10", "of:0000000000000003/10" ],
                          "h5v4": [ "of:0000000000000002/11", "of:0000000000000003/11" ] }
        lib.verifyHostLocations( main, hostLocations )
        linksToRemove = [ ["spine101", "leaf2"], ["spine102", "leaf2"] ]
        lib.killLinkBatch( main, linksToRemove, 40, 10 )
        # TODO: more verifications are required
        verify( main )
        hostLocations = { "h4v6": "of:0000000000000003/6",
                          "h5v6": "of:0000000000000003/7",
                          "h4v4": "of:0000000000000003/10",
                          "h5v4": "of:0000000000000003/11" }
        lib.verifyHostLocations( main, hostLocations )
        lib.restoreLinkBatch( main, linksToRemove, 48, 10 )
        verify( main )
        hostLocations = { "h4v6": [ "of:0000000000000002/7", "of:0000000000000003/6" ],
                          "h5v6": [ "of:0000000000000002/8", "of:0000000000000003/7" ],
                          "h4v4": [ "of:0000000000000002/10", "of:0000000000000003/10" ],
                          "h5v4": [ "of:0000000000000002/11", "of:0000000000000003/11" ] }
        lib.verifyHostLocations( main, hostLocations )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE630( self, main ):
        """
        Bring an instance down
        Drop a device
        Bring that same instance up again and observe that this specific instance sees that the device is down.
        """
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        from core import utilities
        main.case( "Bring an instance down and drop a device" )
        setupTest( main, test_idx=630, onosNodes=3 )
        onosToKill = 0
        deviceToDrop = "spine101"
        lib.killOnos( main, [ onosToKill ], 10, 48, 2 )
        lib.killSwitch( main, deviceToDrop, 9, 30 )
        lib.recoverOnos( main, [ onosToKill ], 9, 30, 3 )
        result = main.Cluster.runningNodes[ onosToKill ].CLI.checkStatus( 9, 30, 3 )
        utilities.assert_equals( expect=main.TRUE, actual=result,
                                 onpass="ONOS instance {} sees correct device numbers".format( onosToKill ),
                                 onfail="ONOS instance {} doesn't see correct device numbers".format( onosToKill ) )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE640( self, main ):
        """
        Controller instance going down and switch coming down at the same time and then we bring them up together

        A. Instance goes down and SPINE-1 goes down
            - All connectivity should be there
            - Bring them up together
            - All connectivity should be there
        B. Instance goes down and HAGG-1 goes down
            - All connectivity should be there
            - Bring them up together
            - All connectivity should be there
        C. Instance goes down and a paired leaf switch goes down
            - Single homed hosts in this leaf should lose connectivity all others should be ok
            - Bring them up together
            - Test connectivity
        """
        import time
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Drop an ONOS instance and switch(es) at the same time" )
        caseDict = { 'A': { 'switches': "spine101",
                            'disconnectedV4': [],
                            'disconnectedV6': [],
                            'expectedSwitches': 9,
                            'expectedLinks': 30 },
                     'B': { 'switches': "spine103",
                            'disconnectedV4': [],
                            'disconnectedV6': [],
                            'expectedSwitches': 9,
                            'expectedLinks': 42 },
                     'C': { 'switches': "leaf2",
                            'disconnectedV4': [ "h3v4" ],
                            'disconnectedV6': [ "h3v6" ],
                            'expectedSwitches': 9,
                            'expectedLinks': 38 } }
        totalSwitches = int( main.params[ 'TOPO' ][ 'switchNum' ] )
        totalLinks = int( main.params[ 'TOPO' ][ 'linkNum' ] )
        nodeIndex = 0
        cases = sorted( caseDict.keys() )
        for case in cases:
            switches = caseDict[ case ][ 'switches' ]
            expectedSwitches = caseDict[ case ][ 'expectedSwitches' ]
            expectedLinks = caseDict[ case ][ 'expectedLinks' ]
            main.step( "\n640{}: Drop ONOS{} and switch(es) {} at the same time".format( case,
                                                                                         nodeIndex + 1,
                                                                                         switches ) )
            setupTest( main, test_idx=640 )
            main.Cluster.next().CLI.balanceMasters()
            time.sleep( float( main.params[ 'timers' ][ 'balanceMasterSleep' ] ) )
            main.Network.discoverHosts( hostList=main.internalIpv4Hosts + main.internalIpv6Hosts )
            instance = main.Cluster.controllers[ nodeIndex ]
            verify( main, disconnected=False, external=False )

            # Simultaneous failures
            main.step( "Kill ONOS{}: {}".format( nodeIndex + 1, instance.ipAddress ) )
            killResult = main.ONOSbench.onosDie( instance.ipAddress )
            utilities.assert_equals( expect=main.TRUE, actual=killResult,
                                     onpass="ONOS node killed",
                                     onfail="Failed to kill ONOS node" )
            instance.active = False
            main.Cluster.reset()
            # TODO: Remove sleeps from the concurrent events
            lib.killSwitch( main, switches, expectedSwitches, expectedLinks )
            main.disconnectedIpv4Hosts = caseDict[ case ][ 'disconnectedV4' ]
            main.disconnectedIpv6Hosts = caseDict[ case ][ 'disconnectedV6' ]

            # verify functionality
            main.log.debug( main.Cluster.next().summary() )
            main.Network.discoverHosts( hostList=main.internalIpv4Hosts + main.internalIpv6Hosts )
            main.log.debug( main.Cluster.next().summary() )
            lib.verifyTopology( main, expectedSwitches, expectedLinks, main.Cluster.numCtrls - 1  )
            lib.verifyNodes( main )
            verify( main, external=False )

            # Bring everything back up
            lib.recoverSwitch( main, switches, totalSwitches, totalLinks, rediscoverHosts=True )
            main.disconnectedIpv4Hosts = []
            main.disconnectedIpv6Hosts = []
            lib.recoverOnos( main, [ nodeIndex ], expectedSwitches, expectedLinks, main.Cluster.numCtrls )

            # Verify functionality
            lib.verifyNodes( main )
            verify( main, disconnected=False, external=False )
            lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )
            nodeIndex = ( nodeIndex + 1 ) % main.Cluster.numCtrls

    def CASE641( self, main ):
        """
        Controller instance going down while switch comes up at the same time

        A. Take down SPINE-1
            - Test connectivity
            - Bring up SPINE-1 and drop an instance at the same time
            - Test connectivity
            - Bring up instance one
            - Test connectivity
        B. Take down HAGG-1
            - Test connectivity
            - Bring up HAGG-1 and drop an instance at the same time
            - Test connectivity
            - Bring up instance one
            - Test connectivity
        C. Take down a paired leaf switch
            - Test connectivity ( single homed hosts on this leaf will lose it )
            - Bring up paired leaf switch and drop a controller instance at the same time
            - Test connectivity
            - Bring up the instance
            - Test connectivity
        """
        import time
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Drop an ONOS instance and recover switch(es) at the same time" )
        caseDict = { 'A': { 'switches': "spine101",
                            'disconnectedV4': [],
                            'disconnectedV6': [],
                            'expectedSwitches': 9,
                            'expectedLinks': 30 },
                     'B': { 'switches': "spine103",
                            'disconnectedV4': [],
                            'disconnectedV6': [],
                            'expectedSwitches': 9,
                            'expectedLinks': 42 },
                     'C': { 'switches': "leaf2",
                            'disconnectedV4': [ "h3v4" ],
                            'disconnectedV6': [ "h3v6" ],
                            'expectedSwitches': 9,
                            'expectedLinks': 38 } }
        totalSwitches = int( main.params[ 'TOPO' ][ 'switchNum' ] )
        totalLinks = int( main.params[ 'TOPO' ][ 'linkNum' ] )
        nodeIndex = 0
        cases = sorted( caseDict.keys() )
        for case in cases:
            switches = caseDict[ case ][ 'switches' ]
            expectedSwitches = caseDict[ case ][ 'expectedSwitches' ]
            expectedLinks = caseDict[ case ][ 'expectedLinks' ]
            main.step( "\n641{}: Drop ONOS{} and recover switch(es) {} at the same time".format( case,
                                                                                                 nodeIndex + 1,
                                                                                                 switches ) )
            setupTest( main, test_idx=641 )
            main.Cluster.next().CLI.balanceMasters()
            time.sleep( float( main.params[ 'timers' ][ 'balanceMasterSleep' ] ) )
            main.Network.discoverHosts( hostList=main.internalIpv4Hosts + main.internalIpv6Hosts )
            instance = main.Cluster.controllers[ nodeIndex ]
            verify( main, disconnected=False, external=False )
            # Drop the switch to setup scenario
            lib.killSwitch( main, switches, expectedSwitches, expectedLinks )
            main.disconnectedIpv4Hosts = caseDict[ case ][ 'disconnectedV4' ]
            main.disconnectedIpv6Hosts = caseDict[ case ][ 'disconnectedV6' ]
            verify( main, external=False )

            # Simultaneous node failure and switch recovery
            main.step( "Kill ONOS{}: {}".format( nodeIndex + 1, instance.ipAddress ) )
            killResult = main.ONOSbench.onosDie( instance.ipAddress )
            utilities.assert_equals( expect=main.TRUE, actual=killResult,
                                     onpass="ONOS node killed",
                                     onfail="Failed to kill ONOS node" )
            instance.active = False
            main.Cluster.reset()
            # TODO: Remove sleeps from the concurrent events
            lib.recoverSwitch( main, switches, totalSwitches, totalLinks, rediscoverHosts=True )
            main.disconnectedIpv4Hosts = []
            main.disconnectedIpv6Hosts = []

            # verify functionality
            main.log.debug( main.Cluster.next().summary() )
            lib.recoverSwitch( main, switches, totalSwitches, totalLinks, rediscoverHosts=True )
            main.log.debug( main.Cluster.next().summary() )
            lib.verifyTopology( main, totalSwitches, totalLinks, main.Cluster.numCtrls - 1 )
            lib.verifyNodes( main )
            verify( main, disconnected=False, external=False )

            # Bring everything back up and verify functionality
            lib.recoverOnos( main, [ nodeIndex ], totalSwitches, totalLinks, main.Cluster.numCtrls )
            lib.verifyNodes( main )
            verify( main, external=False )
            lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )
            nodeIndex = ( nodeIndex + 1 ) % main.Cluster.numCtrls

    def CASE642( self, main ):
        """
        Drop one link from each double link
        Drop a link between DAAS-1 and HAAG-1
        Drop a link between HAGG-2 and SPINE-2
        Drop one ONOS instance
        Test connectivity (expect no failure)
        Bring up all links and ONOS instance
        Test connectivity (expect no failure)
        """
        import time
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Drop ONOS instance and links at the same time" )
        setupTest( main, test_idx=642, onosNodes=3 )
        main.Cluster.active( 0 ).CLI.balanceMasters()
        time.sleep( float( main.params[ 'timers' ][ 'balanceMasterSleep' ] ) )
        verify( main )
        portsToDisable = [ [ "of:0000000000000001", 1 ], [ "of:0000000000000103", 1 ],
                           [ "of:0000000000000006", 1 ], [ "of:0000000000000103", 2 ],
                           [ "of:0000000000000101", 9 ], [ "of:0000000000000103", 3 ],
                           [ "of:0000000000000002", 1 ], [ "of:0000000000000101", 1 ],
                           [ "of:0000000000000003", 1 ], [ "of:0000000000000101", 3 ],
                           [ "of:0000000000000004", 1 ], [ "of:0000000000000101", 5 ],
                           [ "of:0000000000000005", 1 ], [ "of:0000000000000101", 7 ],
                           [ "of:0000000000000002", 3 ], [ "of:0000000000000102", 1 ],
                           [ "of:0000000000000003", 3 ], [ "of:0000000000000102", 3 ],
                           [ "of:0000000000000004", 3 ], [ "of:0000000000000102", 5 ],
                           [ "of:0000000000000005", 3 ], [ "of:0000000000000102", 7 ] ]
        lib.disablePortBatch( main, portsToDisable,
                              int( main.params[ "TOPO" ][ "switchNum" ] ),
                              int( main.params[ "TOPO" ][ "linkNum" ] ) - len( portsToDisable ),
                              sleep=0 )
        lib.killOnos( main, [ 2, ], int( main.params[ "TOPO" ][ "switchNum" ] ),
                      int( main.params[ "TOPO" ][ "linkNum" ] ) - len( portsToDisable ), 2 )
        verify( main )
        lib.enablePortBatch( main, portsToDisable,
                             int( main.params[ "TOPO" ][ "switchNum" ] ),
                             int( main.params[ "TOPO" ][ "linkNum" ] ),
                             sleep=0 )
        lib.recoverOnos( main, [ 2, ], int( main.params[ "TOPO" ][ "switchNum" ] ),
                         int( main.params[ "TOPO" ][ "linkNum" ] ), 3 )
        verify( main )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE643( self, main ):
        """
        Drop one link from each double link
        Drop a link between DAAS-1 and HAAG-1
        Drop a link between HAGG-2 and SPINE-2
        Test connectivity (expect no failure)
        Bring up all links
        Drop one ONOS instance
        Test connectivity (expect no failure)
        Bring up ONOS instance
        Test connectivity (expect no failure)
        """
        import time
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Drop ONOS instances and bring up links at the same time" )
        setupTest( main, test_idx=643, onosNodes=3 )
        main.Cluster.active( 0 ).CLI.balanceMasters()
        time.sleep( float( main.params[ 'timers' ][ 'balanceMasterSleep' ] ) )
        verify( main )
        portsToDisable = [ [ "of:0000000000000001", 1 ], [ "of:0000000000000103", 1 ],
                           [ "of:0000000000000006", 1 ], [ "of:0000000000000103", 2 ],
                           [ "of:0000000000000101", 9 ], [ "of:0000000000000103", 3 ],
                           [ "of:0000000000000002", 1 ], [ "of:0000000000000101", 1 ],
                           [ "of:0000000000000003", 1 ], [ "of:0000000000000101", 3 ],
                           [ "of:0000000000000004", 1 ], [ "of:0000000000000101", 5 ],
                           [ "of:0000000000000005", 1 ], [ "of:0000000000000101", 7 ],
                           [ "of:0000000000000002", 3 ], [ "of:0000000000000102", 1 ],
                           [ "of:0000000000000003", 3 ], [ "of:0000000000000102", 3 ],
                           [ "of:0000000000000004", 3 ], [ "of:0000000000000102", 5 ],
                           [ "of:0000000000000005", 3 ], [ "of:0000000000000102", 7 ] ]
        lib.disablePortBatch( main, portsToDisable,
                              int( main.params[ "TOPO" ][ "switchNum" ] ),
                              int( main.params[ "TOPO" ][ "linkNum" ] ) - len( portsToDisable ) )
        verify( main )
        lib.enablePortBatch( main, portsToDisable,
                             int( main.params[ "TOPO" ][ "switchNum" ] ),
                             int( main.params[ "TOPO" ][ "linkNum" ] ) )
        lib.killOnos( main, [ 2, ], int( main.params[ "TOPO" ][ "switchNum" ] ),
                      int( main.params[ "TOPO" ][ "linkNum" ] ), 2 )
        verify( main )
        lib.recoverOnos( main, [ 2, ], int( main.params[ "TOPO" ][ "switchNum" ] ),
                         int( main.params[ "TOPO" ][ "linkNum" ] ), 3 )
        verify( main )
        lib.cleanup( main, copyKarafLog=False, removeHostComponent=True )

    def CASE651( self, main ):
        """
        Move a single-homed host from port A to port B in DAAS-1
        Test connectivity (expect no failure)

        Repeat with DAAS-2
        """
        import time
        from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import *
        from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib
        main.case( "Move a single-homed host to another port in the same DAAS" )
        setupTest( main, test_idx=651, onosNodes=3 )
        main.Cluster.active( 0 ).CLI.balanceMasters()
        time.sleep( float( main.params[ 'timers' ][ 'balanceMasterSleep' ] ) )
        verify( main )

        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 )
        verify( main )

        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 )
        verify( main )