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

    def CASE1( self, main ):
        """
        Tests connectivity between two untagged hosts
        (Ports are configured as vlan-untagged)

        Sets up 1 ONOS instance
        Start 0x1 single ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 1,
                                topology = '0x1',
                                onosNodes = 1,
                                description = "Bridging test between two untagged hosts on vlan-untagged port" )

    def CASE2( self, main ):
        """
        Tests connectivity between two untagged hosts
        (Ports are configured as vlan-untagged)

        Sets up 1 ONOS instance
        Start 0x2 dual-homed ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 2,
                                topology = '0x2',
                                onosNodes = 1,
                                description = "Bridging test between two untagged hosts on vlan-untagged port" )

    def CASE3( self, main ):
        """
        Tests connectivity between two untagged hosts
        (Ports are configured as vlan-untagged)

        Sets up 1 ONOS instance
        Start 2x2 leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 3,
                                topology = '2x2',
                                onosNodes = 1,
                                description = "Bridging test between two untagged hosts on vlan-untagged port" )

    def CASE4( self, main ):
        """
        Tests connectivity between two untagged hosts
        (Ports are configured as vlan-untagged)

        Sets up 1 ONOS instance
        Start 2x4 dual-homed leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 4,
                                topology = '2x4',
                                onosNodes = 1,
                                description = "Bridging test between two untagged hosts on vlan-untagged port" )

    def CASE5( self, main ):
        """
        Tests connectivity between two untagged hosts
        (Ports are configured as vlan-untagged)

        Sets up 3 ONOS instances
        Start 0x1 single ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 5,
                                topology = '0x1',
                                onosNodes = 3,
                                description = "Bridging test between two untagged hosts on vlan-untagged port" )

    def CASE6( self, main ):
        """
        Tests connectivity between two untagged hosts
        (Ports are configured as vlan-untagged)

        Sets up 3 ONOS instances
        Start 0x2 dual-homed ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 6,
                                topology = '0x2',
                                onosNodes = 3,
                                description = "Bridging test between two untagged hosts on vlan-untagged port" )

    def CASE7( self, main ):
        """
        Tests connectivity between two untagged hosts
        (Ports are configured as vlan-untagged)

        Sets up 3 ONOS instances
        Start 2x2 leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 7,
                                topology = '2x2',
                                onosNodes = 3,
                                description = "Bridging test between two untagged hosts on vlan-untagged port" )

    def CASE8( self, main ):
        """
        Tests connectivity between two untagged hosts
        (Ports are configured as vlan-untagged)

        Sets up 3 ONOS instances
        Start 2x4 dual-homed leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 8,
                                topology = '2x4',
                                onosNodes = 3,
                                description = "Bridging test between two untagged hosts on vlan-untagged port" )

    def CASE11( self, main ):
        """
        Tests connectivity between two tagged hosts
        (Ports are configured as vlan-tagged)

        Sets up 1 ONOS instance
        Start 0x1 single ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 11,
                                topology = '0x1',
                                onosNodes = 1,
                                description = "Bridging test between two tagged hosts",
                                vlan = [ 10, 10 ] )

    def CASE12( self, main ):
        """
        Tests connectivity between two tagged hosts
        (Ports are configured as vlan-tagged)

        Sets up 1 ONOS instance
        Start 0x2 dual-homed ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 12,
                                topology = '0x2',
                                onosNodes = 1,
                                description = "Bridging test between two tagged hosts",
                                vlan = [ 10, 10 ] )

    def CASE13( self, main ):
        """
        Tests connectivity between two tagged hosts
        (Ports are configured as vlan-tagged)

        Sets up 1 ONOS instance
        Start 2x2 leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 13,
                                topology = '2x2',
                                onosNodes = 1,
                                description = "Bridging test between two tagged hosts",
                                vlan = [ 10, 10, 20, 20 ] )

    def CASE14( self, main ):
        """
        Tests connectivity between two tagged hosts
        (Ports are configured as vlan-tagged)

        Sets up 1 ONOS instance
        Start 2x4 dual-homed leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 14,
                                topology = '2x4',
                                onosNodes = 1,
                                description = "Bridging test between two tagged hosts",
                                vlan = [ 10, 10, 20, 20 ] )

    def CASE15( self, main ):
        """
        Tests connectivity between two tagged hosts
        (Ports are configured as vlan-tagged)

        Sets up 3 ONOS instances
        Start 0x1 single ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 15,
                                topology = '0x1',
                                onosNodes = 3,
                                description = "Bridging test between two tagged hosts",
                                vlan = [ 10, 10 ] )

    def CASE16( self, main ):
        """
        Tests connectivity between two tagged hosts
        (Ports are configured as vlan-tagged)

        Sets up 3 ONOS instances
        Start 0x2 dual-homed ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 16,
                                topology = '0x2',
                                onosNodes = 3,
                                description = "Bridging test between two tagged hosts",
                                vlan = [ 10, 10 ] )

    def CASE17( self, main ):
        """
        Tests connectivity between two tagged hosts
        (Ports are configured as vlan-tagged)

        Sets up 3 ONOS instances
        Start 2x2 leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 17,
                                topology = '2x2',
                                onosNodes = 3,
                                description = "Bridging test between two tagged hosts",
                                vlan = [ 10, 10, 20, 20 ] )

    def CASE18( self, main ):
        """
        Tests connectivity between two tagged hosts
        (Ports are configured as vlan-tagged)

        Sets up 3 ONOS instances
        Start 2x4 dual-homed leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 18,
                                topology = '2x4',
                                onosNodes = 3,
                                description = "Bridging test between two tagged hosts",
                                vlan = [ 10, 10, 20, 20 ] )

    def CASE21( self, main ):
        """
        Tests connectivity between two untagged hosts
        (Ports are configured as vlan-native with vlan-tagged)

        Sets up 1 ONOS instance
        Start 0x1 single ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 21,
                                topology = '0x1',
                                onosNodes = 1,
                                description = "Bridging test between two untagged hosts on vlan-native port" )

    def CASE22( self, main ):
        """
        Tests connectivity between two untagged hosts
        (Ports are configured as vlan-native with vlan-tagged)

        Sets up 1 ONOS instance
        Start 0x2 dual-homed ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 22,
                                topology = '0x2',
                                onosNodes = 1,
                                description = "Bridging test between two untagged hosts on vlan-native port" )

    def CASE23( self, main ):
        """
        Tests connectivity between two untagged hosts
        (Ports are configured as vlan-native with vlan-tagged)

        Sets up 1 ONOS instance
        Start 2x2 leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 23,
                                topology = '2x2',
                                onosNodes = 1,
                                description = "Bridging test between two untagged hosts on vlan-native port" )

    def CASE24( self, main ):
        """
        Tests connectivity between two untagged hosts
        (Ports are configured as vlan-native with vlan-tagged)

        Sets up 1 ONOS instance
        Start 2x4 dual-homed leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 24,
                                topology = '2x4',
                                onosNodes = 1,
                                description = "Bridging test between two untagged hosts on vlan-native port" )

    def CASE25( self, main ):
        """
        Tests connectivity between two untagged hosts
        (Ports are configured as vlan-native with vlan-tagged)

        Sets up 3 ONOS instances
        Start 0x1 single ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 25,
                                topology = '0x1',
                                onosNodes = 3,
                                description = "Bridging test between two untagged hosts on vlan-native port" )

    def CASE26( self, main ):
        """
        Tests connectivity between two untagged hosts
        (Ports are configured as vlan-native with vlan-tagged)

        Sets up 3 ONOS instances
        Start 0x2 dual-homed ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 26,
                                topology = '0x2',
                                onosNodes = 3,
                                description = "Bridging test between two untagged hosts on vlan-native port" )

    def CASE27( self, main ):
        """
        Tests connectivity between two untagged hosts
        (Ports are configured as vlan-native with vlan-tagged)

        Sets up 3 ONOS instances
        Start 2x2 leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 27,
                                topology = '2x2',
                                onosNodes = 3,
                                description = "Bridging test between two untagged hosts on vlan-native port" )

    def CASE28( self, main ):
        """
        Tests connectivity between two untagged hosts
        (Ports are configured as vlan-native with vlan-tagged)

        Sets up 3 ONOS instances
        Start 2x4 dual-homed leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 28,
                                topology = '2x4',
                                onosNodes = 3,
                                description = "Bridging test between two untagged hosts on vlan-native port" )

    def CASE31( self, main ):
        """
        Tests connectivity between two untagged hosts
        (One port is configured as vlan-native with vlan-tagged,
        another with vlan-untagged)

        Sets up 1 ONOS instance
        Start 0x1 single ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 31,
                                topology = '0x1',
                                onosNodes = 1,
                                description = "Bridging test between two untagged hosts, "
                                "one on vlan-untagged port and the other on vlan-native port" )

    def CASE32( self, main ):
        """
        Tests connectivity between two untagged hosts
        (One port is configured as vlan-native with vlan-tagged,
        another with vlan-untagged)

        Sets up 1 ONOS instance
        Start 0x2 dual-homed ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 32,
                                topology = '0x2',
                                onosNodes = 1,
                                description = "Bridging test between two untagged hosts, "
                                "one on vlan-untagged port and the other on vlan-native port" )

    def CASE33( self, main ):
        """
        Tests connectivity between two untagged hosts
        (One port is configured as vlan-native with vlan-tagged,
        another with vlan-untagged)

        Sets up 1 ONOS instance
        Start 2x2 leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 33,
                                topology = '2x2',
                                onosNodes = 1,
                                description = "Bridging test between two untagged hosts, "
                                "one on vlan-untagged port and the other on vlan-native port" )

    def CASE34( self, main ):
        """
        Tests connectivity between two untagged hosts
        (One port is configured as vlan-native with vlan-tagged,
        another with vlan-untagged)

        Sets up 1 ONOS instance
        Start 2x4 dual-homed leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 34,
                                topology = '2x4',
                                onosNodes = 1,
                                description = "Bridging test between two untagged hosts, "
                                "one on vlan-untagged port and the other on vlan-native port" )

    def CASE35( self, main ):
        """
        Tests connectivity between two untagged hosts
        (One port is configured as vlan-native with vlan-tagged,
        another with vlan-untagged)

        Sets up 3 ONOS instances
        Start 0x1 single ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 35,
                                topology = '0x1',
                                onosNodes = 3,
                                description = "Bridging test between two untagged hosts, "
                                "one on vlan-untagged port and the other on vlan-native port" )

    def CASE36( self, main ):
        """
        Tests connectivity between two untagged hosts
        (One port is configured as vlan-native with vlan-tagged,
        another with vlan-untagged)

        Sets up 3 ONOS instances
        Start 0x2 dual-homed ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 36,
                                topology = '0x2',
                                onosNodes = 3,
                                description = "Bridging test between two untagged hosts, "
                                "one on vlan-untagged port and the other on vlan-native port" )

    def CASE37( self, main ):
        """
        Tests connectivity between two untagged hosts
        (One port is configured as vlan-native with vlan-tagged,
        another with vlan-untagged)

        Sets up 3 ONOS instances
        Start 2x2 leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 37,
                                topology = '2x2',
                                onosNodes = 3,
                                description = "Bridging test between two untagged hosts, "
                                "one on vlan-untagged port and the other on vlan-native port" )

    def CASE38( self, main ):
        """
        Tests connectivity between two untagged hosts
        (One port is configured as vlan-native with vlan-tagged,
        another with vlan-untagged)

        Sets up 3 ONOS instances
        Start 2x4 dual-homed leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest(main,
                               test_idx = 38,
                               topology = '2x4',
                               onosNodes = 3,
                               description = "Bridging test between two untagged hosts, "
                                           "one on vlan-untagged port and the other on vlan-native port" )

    def CASE41( self, main ):
        """
        Tests connectivity between untagged host and tagged host
        (Ports are configured as vlan-untagged and
        vlan-tagged with same vlan id, respectively)

        Sets up 1 ONOS instance
        Start 0x1 single ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 41,
                                topology = '0x1',
                                onosNodes = 1,
                                description = "Bridging test between untagged host and tagged host",
                                vlan = [ 0, 10 ] )

    def CASE42( self, main ):
        """
        Tests connectivity between untagged host and tagged host
        (Ports are configured as vlan-untagged and
        vlan-tagged with same vlan id, respectively)

        Sets up 1 ONOS instance
        Start 0x2 dual-homed ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 42,
                                topology = '0x2',
                                onosNodes = 1,
                                description = "Bridging test between untagged host and tagged host",
                                vlan = [ 0, 10 ] )

    def CASE43( self, main ):
        """
        Tests connectivity between untagged host and tagged host
        (Ports are configured as vlan-untagged and
        vlan-tagged with same vlan id, respectively)

        Sets up 1 ONOS instance
        Start 2x2 leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 43,
                                topology = '2x2',
                                onosNodes = 1,
                                description = "Bridging test between untagged host and tagged host",
                                vlan = [ 0, 10, 0, 20 ] )

    def CASE44( self, main ):
        """
        Tests connectivity between untagged host and tagged host
        (Ports are configured as vlan-untagged and
        vlan-tagged with same vlan id, respectively)

        Sets up 1 ONOS instance
        Start 2x4 dual-homed leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 44,
                                topology = '2x4',
                                onosNodes = 1,
                                description = "Bridging test between untagged host and tagged host",
                                vlan = [ 0, 10, 0, 20 ] )

    def CASE45( self, main ):
        """
        Tests connectivity between untagged host and tagged host
        (Ports are configured as vlan-untagged and
        vlan-tagged with same vlan id, respectively)

        Sets up 3 ONOS instances
        Start 0x1 single ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 45,
                                topology = '0x1',
                                onosNodes = 3,
                                description = "Bridging test between untagged host and tagged host",
                                vlan = [ 0, 10 ] )

    def CASE46( self, main ):
        """
        Tests connectivity between untagged host and tagged host
        (Ports are configured as vlan-untagged and
        vlan-tagged with same vlan id, respectively)

        Sets up 3 ONOS instances
        Start 0x2 dual-homed ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 46,
                                topology = '0x2',
                                onosNodes = 3,
                                description = "Bridging test between untagged host and tagged host",
                                vlan = [ 0, 10 ] )

    def CASE47( self, main ):
        """
        Tests connectivity between untagged host and tagged host
        (Ports are configured as vlan-untagged and
        vlan-tagged with same vlan id, respectively)

        Sets up 3 ONOS instances
        Start 2x2 leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 47,
                                topology = '2x2',
                                onosNodes = 3,
                                description = "Bridging test between untagged host and tagged host",
                                vlan = [ 0, 10, 0, 20 ] )

    def CASE48( self, main ):
        """
        Tests connectivity between untagged host and tagged host
        (Ports are configured as vlan-untagged and
        vlan-tagged with same vlan id, respectively)

        Sets up 3 ONOS instances
        Start 2x4 dual-homed leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 48,
                                topology = '2x4',
                                onosNodes = 3,
                                description = "Bridging test between untagged host and tagged host",
                                vlan = [ 0, 10, 0, 20 ] )

    def CASE51( self, main ):
        """
        Tests connectivity between two untagged hosts with different vlan id
        (Ports are configured as vlan-untagged 10 and 20, respectively)

        Sets up 1 ONOS instance
        Start 0x1 single ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 51,
                                topology = '0x1',
                                onosNodes = 1,
                                description = "Bridging test between two untagged hosts with different vlan id" )

    def CASE52( self, main ):
        """
        Tests connectivity between two untagged hosts with different vlan id
        (Ports are configured as vlan-untagged 10 and 20, respectively)

        Sets up 1 ONOS instance
        Start 0x2 dual-homed ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 52,
                                topology = '0x2',
                                onosNodes = 1,
                                description = "Bridging test between two untagged hosts with different vlan id" )

    def CASE53( self, main ):
        """
        Tests connectivity between two untagged hosts with different vlan id
        (Ports are configured as vlan-untagged 10 and 20, respectively)

        Sets up 1 ONOS instance
        Start 2x2 leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 53,
                                topology = '2x2',
                                onosNodes = 1,
                                description = "Bridging test between two untagged hosts with different vlan id" )

    def CASE54( self, main ):
        """
        Tests connectivity between two untagged hosts with different vlan id
        (Ports are configured as vlan-untagged 10 and 20, respectively)

        Sets up 1 ONOS instance
        Start 2x4 dual-homed leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 54,
                                topology = '2x4',
                                onosNodes = 1,
                                description = "Bridging test between two untagged hosts with different vlan id" )

    def CASE55( self, main ):
        """
        Tests connectivity between two untagged hosts with different vlan id
        (Ports are configured as vlan-untagged 10 and 20, respectively)

        Sets up 3 ONOS instances
        Start 0x1 single ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 55,
                                topology = '0x1',
                                onosNodes = 3,
                                description = "Bridging test between two untagged hosts with different vlan id" )

    def CASE56( self, main ):
        """
        Tests connectivity between two untagged hosts with different vlan id
        (Ports are configured as vlan-untagged 10 and 20, respectively)

        Sets up 3 ONOS instances
        Start 0x2 dual-homed ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 56,
                                topology = '0x2',
                                onosNodes = 3,
                                description = "Bridging test between two untagged hosts with different vlan id" )

    def CASE57( self, main ):
        """
        Tests connectivity between two untagged hosts with different vlan id
        (Ports are configured as vlan-untagged 10 and 20, respectively)

        Sets up 3 ONOS instances
        Start 2x2 leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 57,
                                topology = '2x2',
                                onosNodes = 3,
                                description = "Bridging test between two untagged hosts with different vlan id" )

    def CASE58( self, main ):
        """
        Tests connectivity between two untagged hosts with different vlan id
        (Ports are configured as vlan-untagged 10 and 20, respectively)

        Sets up 3 ONOS instances
        Start 2x4 dual-homed leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 58,
                                topology = '2x4',
                                onosNodes = 3,
                                description = "Bridging test between two untagged hosts with different vlan id" )

    def CASE61( self, main ):
        """
        Tests connectivity between two tagged hosts with different vlan id
        (Ports are configured as vlan-tagged 10 and 20, respectively)

        Sets up 1 ONOS instance
        Start 0x1 single ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 61,
                                topology = '0x1',
                                onosNodes = 1,
                                description = "Bridging test between two tagged hosts with different vlan id",
                                vlan = [ 10, 20 ] )

    def CASE62( self, main ):
        """
        Tests connectivity between two tagged hosts with different vlan id
        (Ports are configured as vlan-tagged 10 and 20, respectively)

        Sets up 1 ONOS instance
        Start 0x2 dual-homed ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 62,
                                topology = '0x2',
                                onosNodes = 1,
                                description = "Bridging test between two tagged hosts with different vlan id",
                                vlan = [ 10, 20 ] )

    def CASE63( self, main ):
        """
        Tests connectivity between two tagged hosts with different vlan id
        (Ports are configured as vlan-tagged 10 and 20, respectively)

        Sets up 1 ONOS instance
        Start 2x2 leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 63,
                                topology = '2x2',
                                onosNodes = 1,
                                description = "Bridging test between two tagged hosts with different vlan id",
                                vlan = [ 10, 20, 30, 40 ] )

    def CASE64( self, main ):
        """
        Tests connectivity between two tagged hosts with different vlan id
        (Ports are configured as vlan-tagged 10 and 20, respectively)

        Sets up 1 ONOS instance
        Start 2x4 dual-homed leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 64,
                                topology = '2x4',
                                onosNodes = 1,
                                description = "Bridging test between two tagged hosts with different vlan id",
                                vlan = [ 10, 20, 30, 40 ] )

    def CASE65( self, main ):
        """
        Tests connectivity between two tagged hosts with different vlan id
        (Ports are configured as vlan-tagged 10 and 20, respectively)

        Sets up 3 ONOS instances
        Start 0x1 single ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 65,
                                topology = '0x1',
                                onosNodes = 3,
                                description = "Bridging test between two tagged hosts with different vlan id",
                                vlan = [ 10, 20 ] )

    def CASE66( self, main ):
        """
        Tests connectivity between two tagged hosts with different vlan id
        (Ports are configured as vlan-tagged 10 and 20, respectively)

        Sets up 3 ONOS instances
        Start 0x2 dual-homed ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 66,
                                topology = '0x2',
                                onosNodes = 3,
                                description = "Bridging test between two tagged hosts with different vlan id",
                                vlan = [ 10, 20 ] )

    def CASE67( self, main ):
        """
        Tests connectivity between two tagged hosts with different vlan id
        (Ports are configured as vlan-tagged 10 and 20, respectively)

        Sets up 3 ONOS instances
        Start 2x2 leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 67,
                                topology = '2x2',
                                onosNodes = 3,
                                description = "Bridging test between two tagged hosts with different vlan id",
                                vlan = [ 10, 20, 30, 40 ] )

    def CASE68( self, main ):
        """
        Tests connectivity between two tagged hosts with different vlan id
        (Ports are configured as vlan-tagged 10 and 20, respectively)

        Sets up 3 ONOS instances
        Start 2x4 dual-homed leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 68,
                                topology = '2x4',
                                onosNodes = 3,
                                description = "Bridging test between two tagged hosts with different vlan id",
                                vlan = [ 10, 20, 30, 40 ] )

    def CASE71( self, main ):
        """
        Tests connectivity between untagged and tagged hosts with different vlan id
        (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively)

        Sets up 1 ONOS instance
        Start 0x1 single ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 71,
                                topology = '0x1',
                                onosNodes = 1,
                                description = "Bridging test between untagged and tagged hosts with different vlan id",
                                vlan = [ 0, 20 ] )

    def CASE72( self, main ):
        """
        Tests connectivity between untagged and tagged hosts with different vlan id
        (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively)

        Sets up 1 ONOS instance
        Start 0x2 dual-homed ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 72,
                                topology = '0x2',
                                onosNodes = 1,
                                description = "Bridging test between untagged and tagged hosts with different vlan id",
                                vlan = [ 0, 20 ] )

    def CASE73( self, main ):
        """
        Tests connectivity between untagged and tagged hosts with different vlan id
        (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively)

        Sets up 1 ONOS instance
        Start 2x2 leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 73,
                                topology = '2x2',
                                onosNodes = 1,
                                description = "Bridging test between untagged and tagged hosts with different vlan id",
                                vlan = [ 0, 20, 0, 40 ] )

    def CASE74( self, main ):
        """
        Tests connectivity between untagged and tagged hosts with different vlan id
        (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively)

        Sets up 1 ONOS instance
        Start 2x2 dual-homed leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 74,
                                topology = '2x4',
                                onosNodes = 1,
                                description = "Bridging test between untagged and tagged hosts with different vlan id",
                                vlan = [ 0, 20, 0, 40 ] )

    def CASE75( self, main ):
        """
        Tests connectivity between untagged and tagged hosts with different vlan id
        (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively)

        Sets up 3 ONOS instances
        Start 0x1 single ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 75,
                                topology = '0x1',
                                onosNodes = 3,
                                description = "Bridging test between untagged and tagged hosts with different vlan id",
                                vlan = [ 0, 20 ] )

    def CASE76( self, main ):
        """
        Tests connectivity between untagged and tagged hosts with different vlan id
        (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively)

        Sets up 3 ONOS instances
        Start 0x2 dual-homed ToR topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 76,
                                topology = '0x2',
                                onosNodes = 3,
                                description = "Bridging test between untagged and tagged hosts with different vlan id",
                                vlan = [ 0, 20 ] )

    def CASE77( self, main ):
        """
        Tests connectivity between untagged and tagged hosts with different vlan id
        (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively)

        Sets up 3 ONOS instances
        Start 2x2 leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 77,
                                topology = '2x2',
                                onosNodes = 3,
                                description = "Bridging test between untagged and tagged hosts with different vlan id",
                                vlan = [ 0, 20, 0, 40 ] )

    def CASE78( self, main ):
        """
        Tests connectivity between untagged and tagged hosts with different vlan id
        (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively)

        Sets up 3 ONOS instances
        Start 2x2 dual-homed leaf-spine topology
        Pingall
        """
        from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest
        SRBridgingTest.runTest( main,
                                test_idx = 78,
                                topology = '2x4',
                                onosNodes = 3,
                                description = "Bridging test between untagged and tagged hosts with different vlan id",
                                vlan = [ 0, 20, 0, 40 ] )