| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1 | class SRBridging: |
| 2 | def __init__( self ): |
| 3 | self.default = '' |
| 4 | |
| 5 | def CASE1( self, main ): |
| 6 | """ |
| 7 | Tests connectivity between two untagged hosts |
| 8 | (Ports are configured as vlan-untagged) |
| 9 | |
| 10 | Sets up 1 ONOS instance |
| 11 | Start 0x1 single ToR topology |
| 12 | Pingall |
| 13 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 14 | try: |
| 15 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 16 | except ImportError: |
| 17 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 18 | main.cleanAndExit() |
| 19 | try: |
| 20 | main.funcs |
| 21 | except ( NameError, AttributeError ): |
| 22 | main.funcs = SRBridgingTest() |
| 23 | main.funcs.runTest( main, |
| 24 | test_idx=1, |
| 25 | topology='0x1', |
| 26 | onosNodes=1, |
| 27 | description="Bridging test between two untagged hosts on vlan-untagged port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 28 | |
| 29 | def CASE2( self, main ): |
| 30 | """ |
| 31 | Tests connectivity between two untagged hosts |
| 32 | (Ports are configured as vlan-untagged) |
| 33 | |
| 34 | Sets up 1 ONOS instance |
| 35 | Start 0x2 dual-homed ToR topology |
| 36 | Pingall |
| 37 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 38 | try: |
| 39 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 40 | except ImportError: |
| 41 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 42 | main.cleanAndExit() |
| 43 | try: |
| 44 | main.funcs |
| 45 | except ( NameError, AttributeError ): |
| 46 | main.funcs = SRBridgingTest() |
| 47 | main.funcs.runTest( main, |
| 48 | test_idx=2, |
| 49 | topology='0x2', |
| 50 | onosNodes=1, |
| 51 | description="Bridging test between two untagged hosts on vlan-untagged port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 52 | |
| 53 | def CASE3( self, main ): |
| 54 | """ |
| 55 | Tests connectivity between two untagged hosts |
| 56 | (Ports are configured as vlan-untagged) |
| 57 | |
| 58 | Sets up 1 ONOS instance |
| 59 | Start 2x2 leaf-spine topology |
| 60 | Pingall |
| 61 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 62 | try: |
| 63 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 64 | except ImportError: |
| 65 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 66 | main.cleanAndExit() |
| 67 | try: |
| 68 | main.funcs |
| 69 | except ( NameError, AttributeError ): |
| 70 | main.funcs = SRBridgingTest() |
| 71 | main.funcs.runTest( main, |
| 72 | test_idx=3, |
| Siddesh | 167bc88 | 2021-03-23 21:03:43 +0000 | [diff] [blame] | 73 | topology='2x2 dual-linked', |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 74 | onosNodes=1, |
| 75 | description="Bridging test between two untagged hosts on vlan-untagged port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 76 | |
| 77 | def CASE4( self, main ): |
| 78 | """ |
| 79 | Tests connectivity between two untagged hosts |
| 80 | (Ports are configured as vlan-untagged) |
| 81 | |
| 82 | Sets up 1 ONOS instance |
| 83 | Start 2x4 dual-homed leaf-spine topology |
| 84 | Pingall |
| 85 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 86 | try: |
| 87 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 88 | except ImportError: |
| 89 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 90 | main.cleanAndExit() |
| 91 | try: |
| 92 | main.funcs |
| 93 | except ( NameError, AttributeError ): |
| 94 | main.funcs = SRBridgingTest() |
| 95 | main.funcs.runTest( main, |
| 96 | test_idx=4, |
| 97 | topology='2x4', |
| 98 | onosNodes=1, |
| 99 | description="Bridging test between two untagged hosts on vlan-untagged port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 100 | |
| 101 | def CASE5( self, main ): |
| 102 | """ |
| 103 | Tests connectivity between two untagged hosts |
| 104 | (Ports are configured as vlan-untagged) |
| 105 | |
| 106 | Sets up 3 ONOS instances |
| 107 | Start 0x1 single ToR topology |
| 108 | Pingall |
| 109 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 110 | try: |
| 111 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 112 | except ImportError: |
| 113 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 114 | main.cleanAndExit() |
| 115 | try: |
| 116 | main.funcs |
| 117 | except ( NameError, AttributeError ): |
| 118 | main.funcs = SRBridgingTest() |
| 119 | main.funcs.runTest( main, |
| 120 | test_idx=5, |
| 121 | topology='0x1', |
| 122 | onosNodes=3, |
| 123 | description="Bridging test between two untagged hosts on vlan-untagged port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 124 | |
| 125 | def CASE6( self, main ): |
| 126 | """ |
| 127 | Tests connectivity between two untagged hosts |
| 128 | (Ports are configured as vlan-untagged) |
| 129 | |
| 130 | Sets up 3 ONOS instances |
| 131 | Start 0x2 dual-homed ToR topology |
| 132 | Pingall |
| 133 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 134 | try: |
| 135 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 136 | except ImportError: |
| 137 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 138 | main.cleanAndExit() |
| 139 | try: |
| 140 | main.funcs |
| 141 | except ( NameError, AttributeError ): |
| 142 | main.funcs = SRBridgingTest() |
| 143 | main.funcs.runTest( main, |
| 144 | test_idx=6, |
| 145 | topology='0x2', |
| 146 | onosNodes=3, |
| 147 | description="Bridging test between two untagged hosts on vlan-untagged port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 148 | |
| 149 | def CASE7( self, main ): |
| 150 | """ |
| 151 | Tests connectivity between two untagged hosts |
| 152 | (Ports are configured as vlan-untagged) |
| 153 | |
| 154 | Sets up 3 ONOS instances |
| 155 | Start 2x2 leaf-spine topology |
| 156 | Pingall |
| 157 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 158 | try: |
| 159 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 160 | except ImportError: |
| 161 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 162 | main.cleanAndExit() |
| 163 | try: |
| 164 | main.funcs |
| 165 | except ( NameError, AttributeError ): |
| 166 | main.funcs = SRBridgingTest() |
| 167 | main.funcs.runTest( main, |
| 168 | test_idx=7, |
| 169 | topology='2x2', |
| 170 | onosNodes=3, |
| 171 | description="Bridging test between two untagged hosts on vlan-untagged port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 172 | |
| 173 | def CASE8( self, main ): |
| 174 | """ |
| 175 | Tests connectivity between two untagged hosts |
| 176 | (Ports are configured as vlan-untagged) |
| 177 | |
| 178 | Sets up 3 ONOS instances |
| 179 | Start 2x4 dual-homed leaf-spine topology |
| 180 | Pingall |
| 181 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 182 | try: |
| 183 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 184 | except ImportError: |
| 185 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 186 | main.cleanAndExit() |
| 187 | try: |
| 188 | main.funcs |
| 189 | except ( NameError, AttributeError ): |
| 190 | main.funcs = SRBridgingTest() |
| 191 | main.funcs.runTest( main, |
| 192 | test_idx=8, |
| 193 | topology='2x4', |
| 194 | onosNodes=3, |
| 195 | description="Bridging test between two untagged hosts on vlan-untagged port" ) |
| Siddesh | a19e3c8 | 2021-06-09 22:45:27 +0000 | [diff] [blame] | 196 | |
| Siddesh | 167bc88 | 2021-03-23 21:03:43 +0000 | [diff] [blame] | 197 | def CASE9( self, main ): |
| 198 | """ |
| 199 | Tests connectivity between two untagged hosts |
| 200 | (Ports are configured as vlan-untagged) |
| 201 | |
| 202 | Sets up 3 ONOS instances |
| 203 | Start 2x2 leaf-spine topology |
| 204 | Pingall |
| 205 | """ |
| 206 | try: |
| 207 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 208 | except ImportError: |
| 209 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 210 | main.cleanAndExit() |
| 211 | try: |
| 212 | main.funcs |
| 213 | except ( NameError, AttributeError ): |
| 214 | main.funcs = SRBridgingTest() |
| 215 | main.funcs.runTest( main, |
| Siddesh | a19e3c8 | 2021-06-09 22:45:27 +0000 | [diff] [blame] | 216 | test_idx=9, |
| Siddesh | 167bc88 | 2021-03-23 21:03:43 +0000 | [diff] [blame] | 217 | topology='2x2 dual-linked', |
| 218 | onosNodes=3, |
| 219 | description="Bridging test between two untagged hosts on vlan-untagged port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 220 | |
| 221 | def CASE11( self, main ): |
| 222 | """ |
| 223 | Tests connectivity between two tagged hosts |
| 224 | (Ports are configured as vlan-tagged) |
| 225 | |
| 226 | Sets up 1 ONOS instance |
| 227 | Start 0x1 single ToR topology |
| 228 | Pingall |
| 229 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 230 | try: |
| 231 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 232 | except ImportError: |
| 233 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 234 | main.cleanAndExit() |
| 235 | try: |
| 236 | main.funcs |
| 237 | except ( NameError, AttributeError ): |
| 238 | main.funcs = SRBridgingTest() |
| 239 | main.funcs.runTest( main, |
| 240 | test_idx=11, |
| 241 | topology='0x1', |
| 242 | onosNodes=1, |
| 243 | description="Bridging test between two tagged hosts", |
| 244 | vlan=[ 10, 10 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 245 | |
| 246 | def CASE12( self, main ): |
| 247 | """ |
| 248 | Tests connectivity between two tagged hosts |
| 249 | (Ports are configured as vlan-tagged) |
| 250 | |
| 251 | Sets up 1 ONOS instance |
| 252 | Start 0x2 dual-homed ToR topology |
| 253 | Pingall |
| 254 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 255 | try: |
| 256 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 257 | except ImportError: |
| 258 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 259 | main.cleanAndExit() |
| 260 | try: |
| 261 | main.funcs |
| 262 | except ( NameError, AttributeError ): |
| 263 | main.funcs = SRBridgingTest() |
| 264 | main.funcs.runTest( main, |
| 265 | test_idx=12, |
| 266 | topology='0x2', |
| 267 | onosNodes=1, |
| 268 | description="Bridging test between two tagged hosts", |
| 269 | vlan=[ 10, 10 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 270 | |
| 271 | def CASE13( self, main ): |
| 272 | """ |
| 273 | Tests connectivity between two tagged hosts |
| 274 | (Ports are configured as vlan-tagged) |
| 275 | |
| 276 | Sets up 1 ONOS instance |
| 277 | Start 2x2 leaf-spine topology |
| 278 | Pingall |
| 279 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 280 | try: |
| 281 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 282 | except ImportError: |
| 283 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 284 | main.cleanAndExit() |
| 285 | try: |
| 286 | main.funcs |
| 287 | except ( NameError, AttributeError ): |
| 288 | main.funcs = SRBridgingTest() |
| 289 | main.funcs.runTest( main, |
| 290 | test_idx=13, |
| 291 | topology='2x2', |
| 292 | onosNodes=1, |
| 293 | description="Bridging test between two tagged hosts", |
| 294 | vlan=[ 10, 10, 20, 20 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 295 | |
| 296 | def CASE14( self, main ): |
| 297 | """ |
| 298 | Tests connectivity between two tagged hosts |
| 299 | (Ports are configured as vlan-tagged) |
| 300 | |
| 301 | Sets up 1 ONOS instance |
| 302 | Start 2x4 dual-homed leaf-spine topology |
| 303 | Pingall |
| 304 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 305 | try: |
| 306 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 307 | except ImportError: |
| 308 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 309 | main.cleanAndExit() |
| 310 | try: |
| 311 | main.funcs |
| 312 | except ( NameError, AttributeError ): |
| 313 | main.funcs = SRBridgingTest() |
| 314 | main.funcs.runTest( main, |
| 315 | test_idx=14, |
| 316 | topology='2x4', |
| 317 | onosNodes=1, |
| 318 | description="Bridging test between two tagged hosts", |
| 319 | vlan=[ 10, 10, 20, 20 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 320 | |
| 321 | def CASE15( self, main ): |
| 322 | """ |
| 323 | Tests connectivity between two tagged hosts |
| 324 | (Ports are configured as vlan-tagged) |
| 325 | |
| 326 | Sets up 3 ONOS instances |
| 327 | Start 0x1 single ToR topology |
| 328 | Pingall |
| 329 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 330 | try: |
| 331 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 332 | except ImportError: |
| 333 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 334 | main.cleanAndExit() |
| 335 | try: |
| 336 | main.funcs |
| 337 | except ( NameError, AttributeError ): |
| 338 | main.funcs = SRBridgingTest() |
| 339 | main.funcs.runTest( main, |
| 340 | test_idx=15, |
| 341 | topology='0x1', |
| 342 | onosNodes=3, |
| 343 | description="Bridging test between two tagged hosts", |
| 344 | vlan=[ 10, 10 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 345 | |
| 346 | def CASE16( self, main ): |
| 347 | """ |
| 348 | Tests connectivity between two tagged hosts |
| 349 | (Ports are configured as vlan-tagged) |
| 350 | |
| 351 | Sets up 3 ONOS instances |
| 352 | Start 0x2 dual-homed ToR topology |
| 353 | Pingall |
| 354 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 355 | try: |
| 356 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 357 | except ImportError: |
| 358 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 359 | main.cleanAndExit() |
| 360 | try: |
| 361 | main.funcs |
| 362 | except ( NameError, AttributeError ): |
| 363 | main.funcs = SRBridgingTest() |
| 364 | main.funcs.runTest( main, |
| 365 | test_idx=16, |
| 366 | topology='0x2', |
| 367 | onosNodes=3, |
| 368 | description="Bridging test between two tagged hosts", |
| 369 | vlan=[ 10, 10 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 370 | |
| 371 | def CASE17( self, main ): |
| 372 | """ |
| 373 | Tests connectivity between two tagged hosts |
| 374 | (Ports are configured as vlan-tagged) |
| 375 | |
| 376 | Sets up 3 ONOS instances |
| 377 | Start 2x2 leaf-spine topology |
| 378 | Pingall |
| 379 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 380 | try: |
| 381 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 382 | except ImportError: |
| 383 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 384 | main.cleanAndExit() |
| 385 | try: |
| 386 | main.funcs |
| 387 | except ( NameError, AttributeError ): |
| 388 | main.funcs = SRBridgingTest() |
| 389 | main.funcs.runTest( main, |
| 390 | test_idx=17, |
| 391 | topology='2x2', |
| 392 | onosNodes=3, |
| 393 | description="Bridging test between two tagged hosts", |
| 394 | vlan=[ 10, 10, 20, 20 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 395 | |
| 396 | def CASE18( self, main ): |
| 397 | """ |
| 398 | Tests connectivity between two tagged hosts |
| 399 | (Ports are configured as vlan-tagged) |
| 400 | |
| 401 | Sets up 3 ONOS instances |
| 402 | Start 2x4 dual-homed leaf-spine topology |
| 403 | Pingall |
| 404 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 405 | try: |
| 406 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 407 | except ImportError: |
| 408 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 409 | main.cleanAndExit() |
| 410 | try: |
| 411 | main.funcs |
| 412 | except ( NameError, AttributeError ): |
| 413 | main.funcs = SRBridgingTest() |
| 414 | main.funcs.runTest( main, |
| 415 | test_idx=18, |
| 416 | topology='2x4', |
| 417 | onosNodes=3, |
| 418 | description="Bridging test between two tagged hosts", |
| 419 | vlan=[ 10, 10, 20, 20 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 420 | |
| Siddesh | a19e3c8 | 2021-06-09 22:45:27 +0000 | [diff] [blame] | 421 | def CASE19( self, main ): |
| 422 | """ |
| 423 | Tests connectivity between two tagged hosts |
| 424 | (Ports are configured as vlan-tagged) |
| 425 | |
| 426 | Sets up 3 ONOS instances |
| 427 | Start 2x2 leaf-spine topology |
| 428 | Pingall |
| 429 | """ |
| 430 | try: |
| 431 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 432 | except ImportError: |
| 433 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 434 | main.cleanAndExit() |
| 435 | try: |
| 436 | main.funcs |
| 437 | except ( NameError, AttributeError ): |
| 438 | main.funcs = SRBridgingTest() |
| 439 | main.funcs.runTest( main, |
| 440 | test_idx=19, |
| 441 | topology='2x2 dual-linked', |
| 442 | onosNodes=3, |
| You Wang | ad36bc2 | 2021-06-25 17:04:20 -0700 | [diff] [blame] | 443 | description="Bridging test between two tagged hosts", |
| Siddesh | a19e3c8 | 2021-06-09 22:45:27 +0000 | [diff] [blame] | 444 | vlan=[ 10, 10, 20, 20 ] ) |
| 445 | |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 446 | def CASE21( self, main ): |
| 447 | """ |
| 448 | Tests connectivity between two untagged hosts |
| 449 | (Ports are configured as vlan-native with vlan-tagged) |
| 450 | |
| 451 | Sets up 1 ONOS instance |
| 452 | Start 0x1 single ToR topology |
| 453 | Pingall |
| 454 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 455 | try: |
| 456 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 457 | except ImportError: |
| 458 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 459 | main.cleanAndExit() |
| 460 | try: |
| 461 | main.funcs |
| 462 | except ( NameError, AttributeError ): |
| 463 | main.funcs = SRBridgingTest() |
| 464 | main.funcs.runTest( main, |
| 465 | test_idx=21, |
| 466 | topology='0x1', |
| 467 | onosNodes=1, |
| 468 | description="Bridging test between two untagged hosts on vlan-native port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 469 | |
| 470 | def CASE22( self, main ): |
| 471 | """ |
| 472 | Tests connectivity between two untagged hosts |
| 473 | (Ports are configured as vlan-native with vlan-tagged) |
| 474 | |
| 475 | Sets up 1 ONOS instance |
| 476 | Start 0x2 dual-homed ToR topology |
| 477 | Pingall |
| 478 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 479 | try: |
| 480 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 481 | except ImportError: |
| 482 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 483 | main.cleanAndExit() |
| 484 | try: |
| 485 | main.funcs |
| 486 | except ( NameError, AttributeError ): |
| 487 | main.funcs = SRBridgingTest() |
| 488 | main.funcs.runTest( main, |
| 489 | test_idx=22, |
| 490 | topology='0x2', |
| 491 | onosNodes=1, |
| 492 | description="Bridging test between two untagged hosts on vlan-native port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 493 | |
| 494 | def CASE23( self, main ): |
| 495 | """ |
| 496 | Tests connectivity between two untagged hosts |
| 497 | (Ports are configured as vlan-native with vlan-tagged) |
| 498 | |
| 499 | Sets up 1 ONOS instance |
| 500 | Start 2x2 leaf-spine topology |
| 501 | Pingall |
| 502 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 503 | try: |
| 504 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 505 | except ImportError: |
| 506 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 507 | main.cleanAndExit() |
| 508 | try: |
| 509 | main.funcs |
| 510 | except ( NameError, AttributeError ): |
| 511 | main.funcs = SRBridgingTest() |
| 512 | main.funcs.runTest( main, |
| 513 | test_idx=23, |
| 514 | topology='2x2', |
| 515 | onosNodes=1, |
| 516 | description="Bridging test between two untagged hosts on vlan-native port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 517 | |
| 518 | def CASE24( self, main ): |
| 519 | """ |
| 520 | Tests connectivity between two untagged hosts |
| 521 | (Ports are configured as vlan-native with vlan-tagged) |
| 522 | |
| 523 | Sets up 1 ONOS instance |
| 524 | Start 2x4 dual-homed leaf-spine topology |
| 525 | Pingall |
| 526 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 527 | try: |
| 528 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 529 | except ImportError: |
| 530 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 531 | main.cleanAndExit() |
| 532 | try: |
| 533 | main.funcs |
| 534 | except ( NameError, AttributeError ): |
| 535 | main.funcs = SRBridgingTest() |
| 536 | main.funcs.runTest( main, |
| 537 | test_idx=24, |
| 538 | topology='2x4', |
| 539 | onosNodes=1, |
| 540 | description="Bridging test between two untagged hosts on vlan-native port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 541 | |
| 542 | def CASE25( self, main ): |
| 543 | """ |
| 544 | Tests connectivity between two untagged hosts |
| 545 | (Ports are configured as vlan-native with vlan-tagged) |
| 546 | |
| 547 | Sets up 3 ONOS instances |
| 548 | Start 0x1 single ToR topology |
| 549 | Pingall |
| 550 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 551 | try: |
| 552 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 553 | except ImportError: |
| 554 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 555 | main.cleanAndExit() |
| 556 | try: |
| 557 | main.funcs |
| 558 | except ( NameError, AttributeError ): |
| 559 | main.funcs = SRBridgingTest() |
| 560 | main.funcs.runTest( main, |
| 561 | test_idx=25, |
| 562 | topology='0x1', |
| 563 | onosNodes=3, |
| 564 | description="Bridging test between two untagged hosts on vlan-native port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 565 | |
| 566 | def CASE26( self, main ): |
| 567 | """ |
| 568 | Tests connectivity between two untagged hosts |
| 569 | (Ports are configured as vlan-native with vlan-tagged) |
| 570 | |
| 571 | Sets up 3 ONOS instances |
| 572 | Start 0x2 dual-homed ToR topology |
| 573 | Pingall |
| 574 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 575 | try: |
| 576 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 577 | except ImportError: |
| 578 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 579 | main.cleanAndExit() |
| 580 | try: |
| 581 | main.funcs |
| 582 | except ( NameError, AttributeError ): |
| 583 | main.funcs = SRBridgingTest() |
| 584 | main.funcs.runTest( main, |
| 585 | test_idx=26, |
| 586 | topology='0x2', |
| 587 | onosNodes=3, |
| 588 | description="Bridging test between two untagged hosts on vlan-native port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 589 | |
| 590 | def CASE27( self, main ): |
| 591 | """ |
| 592 | Tests connectivity between two untagged hosts |
| 593 | (Ports are configured as vlan-native with vlan-tagged) |
| 594 | |
| 595 | Sets up 3 ONOS instances |
| 596 | Start 2x2 leaf-spine topology |
| 597 | Pingall |
| 598 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 599 | try: |
| 600 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 601 | except ImportError: |
| 602 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 603 | main.cleanAndExit() |
| 604 | try: |
| 605 | main.funcs |
| 606 | except ( NameError, AttributeError ): |
| 607 | main.funcs = SRBridgingTest() |
| 608 | main.funcs.runTest( main, |
| 609 | test_idx=27, |
| 610 | topology='2x2', |
| 611 | onosNodes=3, |
| 612 | description="Bridging test between two untagged hosts on vlan-native port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 613 | |
| 614 | def CASE28( self, main ): |
| 615 | """ |
| 616 | Tests connectivity between two untagged hosts |
| 617 | (Ports are configured as vlan-native with vlan-tagged) |
| 618 | |
| 619 | Sets up 3 ONOS instances |
| 620 | Start 2x4 dual-homed leaf-spine topology |
| 621 | Pingall |
| 622 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 623 | try: |
| 624 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 625 | except ImportError: |
| 626 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 627 | main.cleanAndExit() |
| 628 | try: |
| 629 | main.funcs |
| 630 | except ( NameError, AttributeError ): |
| 631 | main.funcs = SRBridgingTest() |
| 632 | main.funcs.runTest( main, |
| 633 | test_idx=28, |
| 634 | topology='2x4', |
| 635 | onosNodes=3, |
| 636 | description="Bridging test between two untagged hosts on vlan-native port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 637 | |
| Siddesh | a19e3c8 | 2021-06-09 22:45:27 +0000 | [diff] [blame] | 638 | def CASE29( self, main ): |
| 639 | """ |
| 640 | Tests connectivity between two untagged hosts |
| 641 | (Ports are configured as vlan-native with vlan-tagged) |
| 642 | |
| 643 | Sets up 3 ONOS instances |
| 644 | Start 2x2 leaf-spine topology |
| 645 | Pingall |
| 646 | """ |
| 647 | try: |
| 648 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 649 | except ImportError: |
| 650 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 651 | main.cleanAndExit() |
| 652 | try: |
| 653 | main.funcs |
| 654 | except ( NameError, AttributeError ): |
| 655 | main.funcs = SRBridgingTest() |
| 656 | main.funcs.runTest( main, |
| 657 | test_idx=29, |
| 658 | topology='2x2 dual-linked', |
| 659 | onosNodes=3, |
| 660 | description="Bridging test between two untagged hosts on vlan-native port" ) |
| 661 | |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 662 | def CASE31( self, main ): |
| 663 | """ |
| 664 | Tests connectivity between two untagged hosts |
| 665 | (One port is configured as vlan-native with vlan-tagged, |
| 666 | another with vlan-untagged) |
| 667 | |
| 668 | Sets up 1 ONOS instance |
| 669 | Start 0x1 single ToR topology |
| 670 | Pingall |
| 671 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 672 | try: |
| 673 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 674 | except ImportError: |
| 675 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 676 | main.cleanAndExit() |
| 677 | try: |
| 678 | main.funcs |
| 679 | except ( NameError, AttributeError ): |
| 680 | main.funcs = SRBridgingTest() |
| 681 | main.funcs.runTest( main, |
| 682 | test_idx=31, |
| 683 | topology='0x1', |
| 684 | onosNodes=1, |
| 685 | description="Bridging test between two untagged hosts, " |
| 686 | "one on vlan-untagged port and the other on vlan-native port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 687 | |
| 688 | def CASE32( self, main ): |
| 689 | """ |
| 690 | Tests connectivity between two untagged hosts |
| 691 | (One port is configured as vlan-native with vlan-tagged, |
| 692 | another with vlan-untagged) |
| 693 | |
| 694 | Sets up 1 ONOS instance |
| 695 | Start 0x2 dual-homed ToR topology |
| 696 | Pingall |
| 697 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 698 | try: |
| 699 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 700 | except ImportError: |
| 701 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 702 | main.cleanAndExit() |
| 703 | try: |
| 704 | main.funcs |
| 705 | except ( NameError, AttributeError ): |
| 706 | main.funcs = SRBridgingTest() |
| 707 | main.funcs.runTest( main, |
| 708 | test_idx=32, |
| 709 | topology='0x2', |
| 710 | onosNodes=1, |
| 711 | description="Bridging test between two untagged hosts, " |
| 712 | "one on vlan-untagged port and the other on vlan-native port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 713 | |
| 714 | def CASE33( self, main ): |
| 715 | """ |
| 716 | Tests connectivity between two untagged hosts |
| 717 | (One port is configured as vlan-native with vlan-tagged, |
| 718 | another with vlan-untagged) |
| 719 | |
| 720 | Sets up 1 ONOS instance |
| 721 | Start 2x2 leaf-spine topology |
| 722 | Pingall |
| 723 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 724 | try: |
| 725 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 726 | except ImportError: |
| 727 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 728 | main.cleanAndExit() |
| 729 | try: |
| 730 | main.funcs |
| 731 | except ( NameError, AttributeError ): |
| 732 | main.funcs = SRBridgingTest() |
| 733 | main.funcs.runTest( main, |
| 734 | test_idx=33, |
| 735 | topology='2x2', |
| 736 | onosNodes=1, |
| 737 | description="Bridging test between two untagged hosts, " |
| 738 | "one on vlan-untagged port and the other on vlan-native port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 739 | |
| 740 | def CASE34( self, main ): |
| 741 | """ |
| 742 | Tests connectivity between two untagged hosts |
| 743 | (One port is configured as vlan-native with vlan-tagged, |
| 744 | another with vlan-untagged) |
| 745 | |
| 746 | Sets up 1 ONOS instance |
| 747 | Start 2x4 dual-homed leaf-spine topology |
| 748 | Pingall |
| 749 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 750 | try: |
| 751 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 752 | except ImportError: |
| 753 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 754 | main.cleanAndExit() |
| 755 | try: |
| 756 | main.funcs |
| 757 | except ( NameError, AttributeError ): |
| 758 | main.funcs = SRBridgingTest() |
| 759 | main.funcs.runTest( main, |
| 760 | test_idx=34, |
| 761 | topology='2x4', |
| 762 | onosNodes=1, |
| 763 | description="Bridging test between two untagged hosts, " |
| 764 | "one on vlan-untagged port and the other on vlan-native port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 765 | |
| 766 | def CASE35( self, main ): |
| 767 | """ |
| 768 | Tests connectivity between two untagged hosts |
| 769 | (One port is configured as vlan-native with vlan-tagged, |
| 770 | another with vlan-untagged) |
| 771 | |
| 772 | Sets up 3 ONOS instances |
| 773 | Start 0x1 single ToR topology |
| 774 | Pingall |
| 775 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 776 | try: |
| 777 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 778 | except ImportError: |
| 779 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 780 | main.cleanAndExit() |
| 781 | try: |
| 782 | main.funcs |
| 783 | except ( NameError, AttributeError ): |
| 784 | main.funcs = SRBridgingTest() |
| 785 | main.funcs.runTest( main, |
| 786 | test_idx=35, |
| 787 | topology='0x1', |
| 788 | onosNodes=3, |
| 789 | description="Bridging test between two untagged hosts, " |
| 790 | "one on vlan-untagged port and the other on vlan-native port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 791 | |
| 792 | def CASE36( self, main ): |
| 793 | """ |
| 794 | Tests connectivity between two untagged hosts |
| 795 | (One port is configured as vlan-native with vlan-tagged, |
| 796 | another with vlan-untagged) |
| 797 | |
| 798 | Sets up 3 ONOS instances |
| 799 | Start 0x2 dual-homed ToR topology |
| 800 | Pingall |
| 801 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 802 | try: |
| 803 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 804 | except ImportError: |
| 805 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 806 | main.cleanAndExit() |
| 807 | try: |
| 808 | main.funcs |
| 809 | except ( NameError, AttributeError ): |
| 810 | main.funcs = SRBridgingTest() |
| 811 | main.funcs.runTest( main, |
| 812 | test_idx=36, |
| 813 | topology='0x2', |
| 814 | onosNodes=3, |
| 815 | description="Bridging test between two untagged hosts, " |
| 816 | "one on vlan-untagged port and the other on vlan-native port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 817 | |
| 818 | def CASE37( self, main ): |
| 819 | """ |
| 820 | Tests connectivity between two untagged hosts |
| 821 | (One port is configured as vlan-native with vlan-tagged, |
| 822 | another with vlan-untagged) |
| 823 | |
| 824 | Sets up 3 ONOS instances |
| 825 | Start 2x2 leaf-spine topology |
| 826 | Pingall |
| 827 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 828 | try: |
| 829 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 830 | except ImportError: |
| 831 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 832 | main.cleanAndExit() |
| 833 | try: |
| 834 | main.funcs |
| 835 | except ( NameError, AttributeError ): |
| 836 | main.funcs = SRBridgingTest() |
| 837 | main.funcs.runTest( main, |
| 838 | test_idx=37, |
| 839 | topology='2x2', |
| 840 | onosNodes=3, |
| 841 | description="Bridging test between two untagged hosts, " |
| 842 | "one on vlan-untagged port and the other on vlan-native port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 843 | |
| 844 | def CASE38( self, main ): |
| 845 | """ |
| 846 | Tests connectivity between two untagged hosts |
| 847 | (One port is configured as vlan-native with vlan-tagged, |
| 848 | another with vlan-untagged) |
| 849 | |
| 850 | Sets up 3 ONOS instances |
| 851 | Start 2x4 dual-homed leaf-spine topology |
| 852 | Pingall |
| 853 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 854 | try: |
| 855 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 856 | except ImportError: |
| 857 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 858 | main.cleanAndExit() |
| 859 | try: |
| 860 | main.funcs |
| 861 | except ( NameError, AttributeError ): |
| 862 | main.funcs = SRBridgingTest() |
| 863 | main.funcs.runTest(main, |
| 864 | test_idx=38, |
| 865 | topology='2x4', |
| 866 | onosNodes=3, |
| 867 | description="Bridging test between two untagged hosts, " |
| 868 | "one on vlan-untagged port and the other on vlan-native port" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 869 | |
| Siddesh | a19e3c8 | 2021-06-09 22:45:27 +0000 | [diff] [blame] | 870 | def CASE39( self, main ): |
| 871 | """ |
| 872 | Tests connectivity between two untagged hosts |
| 873 | (Ports are configured as vlan-native and vlan-tagged, another with vlan-untagged) |
| 874 | |
| 875 | Sets up 3 ONOS instances |
| 876 | Start 2x2 leaf-spine topology |
| 877 | Pingall |
| 878 | """ |
| 879 | try: |
| 880 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 881 | except ImportError: |
| 882 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 883 | main.cleanAndExit() |
| 884 | try: |
| 885 | main.funcs |
| 886 | except ( NameError, AttributeError ): |
| 887 | main.funcs = SRBridgingTest() |
| 888 | main.funcs.runTest( main, |
| 889 | test_idx=39, |
| 890 | topology='2x2 dual-linked', |
| 891 | onosNodes=3, |
| 892 | description="Bridging test between two untagged hosts, " |
| 893 | "one on vlan-untagged port and the other on vlan-native port" ) |
| 894 | |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 895 | def CASE41( self, main ): |
| 896 | """ |
| 897 | Tests connectivity between untagged host and tagged host |
| 898 | (Ports are configured as vlan-untagged and |
| 899 | vlan-tagged with same vlan id, respectively) |
| 900 | |
| 901 | Sets up 1 ONOS instance |
| 902 | Start 0x1 single ToR topology |
| 903 | Pingall |
| 904 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 905 | try: |
| 906 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 907 | except ImportError: |
| 908 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 909 | main.cleanAndExit() |
| 910 | try: |
| 911 | main.funcs |
| 912 | except ( NameError, AttributeError ): |
| 913 | main.funcs = SRBridgingTest() |
| 914 | main.funcs.runTest( main, |
| 915 | test_idx=41, |
| 916 | topology='0x1', |
| 917 | onosNodes=1, |
| 918 | description="Bridging test between untagged host and tagged host", |
| 919 | vlan=[ 0, 10 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 920 | |
| 921 | def CASE42( self, main ): |
| 922 | """ |
| 923 | Tests connectivity between untagged host and tagged host |
| 924 | (Ports are configured as vlan-untagged and |
| 925 | vlan-tagged with same vlan id, respectively) |
| 926 | |
| 927 | Sets up 1 ONOS instance |
| 928 | Start 0x2 dual-homed ToR topology |
| 929 | Pingall |
| 930 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 931 | try: |
| 932 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 933 | except ImportError: |
| 934 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 935 | main.cleanAndExit() |
| 936 | try: |
| 937 | main.funcs |
| 938 | except ( NameError, AttributeError ): |
| 939 | main.funcs = SRBridgingTest() |
| 940 | main.funcs.runTest( main, |
| 941 | test_idx=42, |
| 942 | topology='0x2', |
| 943 | onosNodes=1, |
| 944 | description="Bridging test between untagged host and tagged host", |
| 945 | vlan=[ 0, 10 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 946 | |
| 947 | def CASE43( self, main ): |
| 948 | """ |
| 949 | Tests connectivity between untagged host and tagged host |
| 950 | (Ports are configured as vlan-untagged and |
| 951 | vlan-tagged with same vlan id, respectively) |
| 952 | |
| 953 | Sets up 1 ONOS instance |
| 954 | Start 2x2 leaf-spine topology |
| 955 | Pingall |
| 956 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 957 | try: |
| 958 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 959 | except ImportError: |
| 960 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 961 | main.cleanAndExit() |
| 962 | try: |
| 963 | main.funcs |
| 964 | except ( NameError, AttributeError ): |
| 965 | main.funcs = SRBridgingTest() |
| 966 | main.funcs.runTest( main, |
| 967 | test_idx=43, |
| 968 | topology='2x2', |
| 969 | onosNodes=1, |
| 970 | description="Bridging test between untagged host and tagged host", |
| 971 | vlan=[ 0, 10, 0, 20 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 972 | |
| 973 | def CASE44( self, main ): |
| 974 | """ |
| 975 | Tests connectivity between untagged host and tagged host |
| 976 | (Ports are configured as vlan-untagged and |
| 977 | vlan-tagged with same vlan id, respectively) |
| 978 | |
| 979 | Sets up 1 ONOS instance |
| 980 | Start 2x4 dual-homed leaf-spine topology |
| 981 | Pingall |
| 982 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 983 | try: |
| 984 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 985 | except ImportError: |
| 986 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 987 | main.cleanAndExit() |
| 988 | try: |
| 989 | main.funcs |
| 990 | except ( NameError, AttributeError ): |
| 991 | main.funcs = SRBridgingTest() |
| 992 | main.funcs.runTest( main, |
| 993 | test_idx=44, |
| 994 | topology='2x4', |
| 995 | onosNodes=1, |
| 996 | description="Bridging test between untagged host and tagged host", |
| 997 | vlan=[ 0, 10, 0, 20 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 998 | |
| 999 | def CASE45( self, main ): |
| 1000 | """ |
| 1001 | Tests connectivity between untagged host and tagged host |
| 1002 | (Ports are configured as vlan-untagged and |
| 1003 | vlan-tagged with same vlan id, respectively) |
| 1004 | |
| 1005 | Sets up 3 ONOS instances |
| 1006 | Start 0x1 single ToR topology |
| 1007 | Pingall |
| 1008 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1009 | try: |
| 1010 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1011 | except ImportError: |
| 1012 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1013 | main.cleanAndExit() |
| 1014 | try: |
| 1015 | main.funcs |
| 1016 | except ( NameError, AttributeError ): |
| 1017 | main.funcs = SRBridgingTest() |
| 1018 | main.funcs.runTest( main, |
| 1019 | test_idx=45, |
| 1020 | topology='0x1', |
| 1021 | onosNodes=3, |
| 1022 | description="Bridging test between untagged host and tagged host", |
| 1023 | vlan=[ 0, 10 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1024 | |
| 1025 | def CASE46( self, main ): |
| 1026 | """ |
| 1027 | Tests connectivity between untagged host and tagged host |
| 1028 | (Ports are configured as vlan-untagged and |
| 1029 | vlan-tagged with same vlan id, respectively) |
| 1030 | |
| 1031 | Sets up 3 ONOS instances |
| 1032 | Start 0x2 dual-homed ToR topology |
| 1033 | Pingall |
| 1034 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1035 | try: |
| 1036 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1037 | except ImportError: |
| 1038 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1039 | main.cleanAndExit() |
| 1040 | try: |
| 1041 | main.funcs |
| 1042 | except ( NameError, AttributeError ): |
| 1043 | main.funcs = SRBridgingTest() |
| 1044 | main.funcs.runTest( main, |
| 1045 | test_idx=46, |
| 1046 | topology='0x2', |
| 1047 | onosNodes=3, |
| 1048 | description="Bridging test between untagged host and tagged host", |
| 1049 | vlan=[ 0, 10 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1050 | |
| 1051 | def CASE47( self, main ): |
| 1052 | """ |
| 1053 | Tests connectivity between untagged host and tagged host |
| 1054 | (Ports are configured as vlan-untagged and |
| 1055 | vlan-tagged with same vlan id, respectively) |
| 1056 | |
| 1057 | Sets up 3 ONOS instances |
| 1058 | Start 2x2 leaf-spine topology |
| 1059 | Pingall |
| 1060 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1061 | try: |
| 1062 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1063 | except ImportError: |
| 1064 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1065 | main.cleanAndExit() |
| 1066 | try: |
| 1067 | main.funcs |
| 1068 | except ( NameError, AttributeError ): |
| 1069 | main.funcs = SRBridgingTest() |
| 1070 | main.funcs.runTest( main, |
| 1071 | test_idx=47, |
| 1072 | topology='2x2', |
| 1073 | onosNodes=3, |
| 1074 | description="Bridging test between untagged host and tagged host", |
| 1075 | vlan=[ 0, 10, 0, 20 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1076 | |
| 1077 | def CASE48( self, main ): |
| 1078 | """ |
| 1079 | Tests connectivity between untagged host and tagged host |
| 1080 | (Ports are configured as vlan-untagged and |
| 1081 | vlan-tagged with same vlan id, respectively) |
| 1082 | |
| 1083 | Sets up 3 ONOS instances |
| 1084 | Start 2x4 dual-homed leaf-spine topology |
| 1085 | Pingall |
| 1086 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1087 | try: |
| 1088 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1089 | except ImportError: |
| 1090 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1091 | main.cleanAndExit() |
| 1092 | try: |
| 1093 | main.funcs |
| 1094 | except ( NameError, AttributeError ): |
| 1095 | main.funcs = SRBridgingTest() |
| 1096 | main.funcs.runTest( main, |
| 1097 | test_idx=48, |
| 1098 | topology='2x4', |
| 1099 | onosNodes=3, |
| 1100 | description="Bridging test between untagged host and tagged host", |
| 1101 | vlan=[ 0, 10, 0, 20 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1102 | |
| Siddesh | a19e3c8 | 2021-06-09 22:45:27 +0000 | [diff] [blame] | 1103 | def CASE49( self, main ): |
| 1104 | """ |
| 1105 | Tests connectivity between untagged host and tagged host |
| 1106 | (Ports are configured as vlan-untagged and |
| 1107 | vlan-tagged with same vlan-id, respectively) |
| 1108 | |
| 1109 | Sets up 3 ONOS instances |
| 1110 | Start 2x2 leaf-spine topology |
| 1111 | Pingall |
| 1112 | """ |
| 1113 | try: |
| 1114 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1115 | except ImportError: |
| 1116 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1117 | main.cleanAndExit() |
| 1118 | try: |
| 1119 | main.funcs |
| 1120 | except ( NameError, AttributeError ): |
| 1121 | main.funcs = SRBridgingTest() |
| 1122 | main.funcs.runTest( main, |
| 1123 | test_idx=49, |
| 1124 | topology='2x2 dual-linked', |
| 1125 | onosNodes=3, |
| 1126 | description="Bridging test between two untagged hostand tagged host", |
| 1127 | vlan=[ 102, 103 ] ) |
| 1128 | |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1129 | def CASE51( self, main ): |
| 1130 | """ |
| 1131 | Tests connectivity between two untagged hosts with different vlan id |
| 1132 | (Ports are configured as vlan-untagged 10 and 20, respectively) |
| 1133 | |
| 1134 | Sets up 1 ONOS instance |
| 1135 | Start 0x1 single ToR topology |
| 1136 | Pingall |
| 1137 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1138 | try: |
| 1139 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1140 | except ImportError: |
| 1141 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1142 | main.cleanAndExit() |
| 1143 | try: |
| 1144 | main.funcs |
| 1145 | except ( NameError, AttributeError ): |
| 1146 | main.funcs = SRBridgingTest() |
| 1147 | main.funcs.runTest( main, |
| 1148 | test_idx=51, |
| 1149 | topology='0x1', |
| 1150 | onosNodes=1, |
| 1151 | description="Bridging test between two untagged hosts with different vlan id" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1152 | |
| 1153 | def CASE52( self, main ): |
| 1154 | """ |
| 1155 | Tests connectivity between two untagged hosts with different vlan id |
| 1156 | (Ports are configured as vlan-untagged 10 and 20, respectively) |
| 1157 | |
| 1158 | Sets up 1 ONOS instance |
| 1159 | Start 0x2 dual-homed ToR topology |
| 1160 | Pingall |
| 1161 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1162 | try: |
| 1163 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1164 | except ImportError: |
| 1165 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1166 | main.cleanAndExit() |
| 1167 | try: |
| 1168 | main.funcs |
| 1169 | except ( NameError, AttributeError ): |
| 1170 | main.funcs = SRBridgingTest() |
| 1171 | main.funcs.runTest( main, |
| 1172 | test_idx=52, |
| 1173 | topology='0x2', |
| 1174 | onosNodes=1, |
| 1175 | description="Bridging test between two untagged hosts with different vlan id" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1176 | |
| 1177 | def CASE53( self, main ): |
| 1178 | """ |
| 1179 | Tests connectivity between two untagged hosts with different vlan id |
| 1180 | (Ports are configured as vlan-untagged 10 and 20, respectively) |
| 1181 | |
| 1182 | Sets up 1 ONOS instance |
| 1183 | Start 2x2 leaf-spine topology |
| 1184 | Pingall |
| 1185 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1186 | try: |
| 1187 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1188 | except ImportError: |
| 1189 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1190 | main.cleanAndExit() |
| 1191 | try: |
| 1192 | main.funcs |
| 1193 | except ( NameError, AttributeError ): |
| 1194 | main.funcs = SRBridgingTest() |
| 1195 | main.funcs.runTest( main, |
| 1196 | test_idx=53, |
| 1197 | topology='2x2', |
| 1198 | onosNodes=1, |
| 1199 | description="Bridging test between two untagged hosts with different vlan id" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1200 | |
| 1201 | def CASE54( self, main ): |
| 1202 | """ |
| 1203 | Tests connectivity between two untagged hosts with different vlan id |
| 1204 | (Ports are configured as vlan-untagged 10 and 20, respectively) |
| 1205 | |
| 1206 | Sets up 1 ONOS instance |
| 1207 | Start 2x4 dual-homed leaf-spine topology |
| 1208 | Pingall |
| 1209 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1210 | try: |
| 1211 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1212 | except ImportError: |
| 1213 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1214 | main.cleanAndExit() |
| 1215 | try: |
| 1216 | main.funcs |
| 1217 | except ( NameError, AttributeError ): |
| 1218 | main.funcs = SRBridgingTest() |
| 1219 | main.funcs.runTest( main, |
| 1220 | test_idx=54, |
| 1221 | topology='2x4', |
| 1222 | onosNodes=1, |
| 1223 | description="Bridging test between two untagged hosts with different vlan id" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1224 | |
| 1225 | def CASE55( self, main ): |
| 1226 | """ |
| 1227 | Tests connectivity between two untagged hosts with different vlan id |
| 1228 | (Ports are configured as vlan-untagged 10 and 20, respectively) |
| 1229 | |
| 1230 | Sets up 3 ONOS instances |
| 1231 | Start 0x1 single ToR topology |
| 1232 | Pingall |
| 1233 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1234 | try: |
| 1235 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1236 | except ImportError: |
| 1237 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1238 | main.cleanAndExit() |
| 1239 | try: |
| 1240 | main.funcs |
| 1241 | except ( NameError, AttributeError ): |
| 1242 | main.funcs = SRBridgingTest() |
| 1243 | main.funcs.runTest( main, |
| 1244 | test_idx=55, |
| 1245 | topology='0x1', |
| 1246 | onosNodes=3, |
| 1247 | description="Bridging test between two untagged hosts with different vlan id" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1248 | |
| 1249 | def CASE56( self, main ): |
| 1250 | """ |
| 1251 | Tests connectivity between two untagged hosts with different vlan id |
| 1252 | (Ports are configured as vlan-untagged 10 and 20, respectively) |
| 1253 | |
| 1254 | Sets up 3 ONOS instances |
| 1255 | Start 0x2 dual-homed ToR topology |
| 1256 | Pingall |
| 1257 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1258 | try: |
| 1259 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1260 | except ImportError: |
| 1261 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1262 | main.cleanAndExit() |
| 1263 | try: |
| 1264 | main.funcs |
| 1265 | except ( NameError, AttributeError ): |
| 1266 | main.funcs = SRBridgingTest() |
| 1267 | main.funcs.runTest( main, |
| 1268 | test_idx=56, |
| 1269 | topology='0x2', |
| 1270 | onosNodes=3, |
| 1271 | description="Bridging test between two untagged hosts with different vlan id" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1272 | |
| 1273 | def CASE57( self, main ): |
| 1274 | """ |
| 1275 | Tests connectivity between two untagged hosts with different vlan id |
| 1276 | (Ports are configured as vlan-untagged 10 and 20, respectively) |
| 1277 | |
| 1278 | Sets up 3 ONOS instances |
| 1279 | Start 2x2 leaf-spine topology |
| 1280 | Pingall |
| 1281 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1282 | try: |
| 1283 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1284 | except ImportError: |
| 1285 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1286 | main.cleanAndExit() |
| 1287 | try: |
| 1288 | main.funcs |
| 1289 | except ( NameError, AttributeError ): |
| 1290 | main.funcs = SRBridgingTest() |
| 1291 | main.funcs.runTest( main, |
| 1292 | test_idx=57, |
| 1293 | topology='2x2', |
| 1294 | onosNodes=3, |
| 1295 | description="Bridging test between two untagged hosts with different vlan id" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1296 | |
| 1297 | def CASE58( self, main ): |
| 1298 | """ |
| 1299 | Tests connectivity between two untagged hosts with different vlan id |
| 1300 | (Ports are configured as vlan-untagged 10 and 20, respectively) |
| 1301 | |
| 1302 | Sets up 3 ONOS instances |
| 1303 | Start 2x4 dual-homed leaf-spine topology |
| 1304 | Pingall |
| 1305 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1306 | try: |
| 1307 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1308 | except ImportError: |
| 1309 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1310 | main.cleanAndExit() |
| 1311 | try: |
| 1312 | main.funcs |
| 1313 | except ( NameError, AttributeError ): |
| 1314 | main.funcs = SRBridgingTest() |
| 1315 | main.funcs.runTest( main, |
| 1316 | test_idx=58, |
| 1317 | topology='2x4', |
| 1318 | onosNodes=3, |
| 1319 | description="Bridging test between two untagged hosts with different vlan id" ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1320 | |
| Siddesh | a19e3c8 | 2021-06-09 22:45:27 +0000 | [diff] [blame] | 1321 | def CASE59( self, main ): |
| 1322 | """ |
| 1323 | Tests connectivity between two untagged hosts with different vlan id |
| 1324 | (Ports are configured as vlan-untagged 10 and 20, respectively) |
| 1325 | |
| 1326 | Sets up 3 ONOS instances |
| 1327 | Start 2x2 leaf-spine topology |
| 1328 | Pingall |
| 1329 | """ |
| 1330 | try: |
| 1331 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1332 | except ImportError: |
| 1333 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1334 | main.cleanAndExit() |
| 1335 | try: |
| 1336 | main.funcs |
| 1337 | except ( NameError, AttributeError ): |
| 1338 | main.funcs = SRBridgingTest() |
| 1339 | main.funcs.runTest( main, |
| 1340 | test_idx=59, |
| 1341 | topology='2x2 dual-linked', |
| 1342 | onosNodes=3, |
| 1343 | description="Bridging test between two untagged hosts with different vlan-id" ) |
| 1344 | |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1345 | def CASE61( self, main ): |
| 1346 | """ |
| 1347 | Tests connectivity between two tagged hosts with different vlan id |
| 1348 | (Ports are configured as vlan-tagged 10 and 20, respectively) |
| 1349 | |
| 1350 | Sets up 1 ONOS instance |
| 1351 | Start 0x1 single ToR topology |
| 1352 | Pingall |
| 1353 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1354 | try: |
| 1355 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1356 | except ImportError: |
| 1357 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1358 | main.cleanAndExit() |
| 1359 | try: |
| 1360 | main.funcs |
| 1361 | except ( NameError, AttributeError ): |
| 1362 | main.funcs = SRBridgingTest() |
| 1363 | main.funcs.runTest( main, |
| 1364 | test_idx=61, |
| 1365 | topology='0x1', |
| 1366 | onosNodes=1, |
| 1367 | description="Bridging test between two tagged hosts with different vlan id", |
| 1368 | vlan=[ 10, 20 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1369 | |
| 1370 | def CASE62( self, main ): |
| 1371 | """ |
| 1372 | Tests connectivity between two tagged hosts with different vlan id |
| 1373 | (Ports are configured as vlan-tagged 10 and 20, respectively) |
| 1374 | |
| 1375 | Sets up 1 ONOS instance |
| 1376 | Start 0x2 dual-homed ToR topology |
| 1377 | Pingall |
| 1378 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1379 | try: |
| 1380 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1381 | except ImportError: |
| 1382 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1383 | main.cleanAndExit() |
| 1384 | try: |
| 1385 | main.funcs |
| 1386 | except ( NameError, AttributeError ): |
| 1387 | main.funcs = SRBridgingTest() |
| 1388 | main.funcs.runTest( main, |
| 1389 | test_idx=62, |
| 1390 | topology='0x2', |
| 1391 | onosNodes=1, |
| 1392 | description="Bridging test between two tagged hosts with different vlan id", |
| 1393 | vlan=[ 10, 20 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1394 | |
| 1395 | def CASE63( self, main ): |
| 1396 | """ |
| 1397 | Tests connectivity between two tagged hosts with different vlan id |
| 1398 | (Ports are configured as vlan-tagged 10 and 20, respectively) |
| 1399 | |
| 1400 | Sets up 1 ONOS instance |
| 1401 | Start 2x2 leaf-spine topology |
| 1402 | Pingall |
| 1403 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1404 | try: |
| 1405 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1406 | except ImportError: |
| 1407 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1408 | main.cleanAndExit() |
| 1409 | try: |
| 1410 | main.funcs |
| 1411 | except ( NameError, AttributeError ): |
| 1412 | main.funcs = SRBridgingTest() |
| 1413 | main.funcs.runTest( main, |
| 1414 | test_idx=63, |
| 1415 | topology='2x2', |
| 1416 | onosNodes=1, |
| 1417 | description="Bridging test between two tagged hosts with different vlan id", |
| 1418 | vlan=[ 10, 20, 30, 40 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1419 | |
| 1420 | def CASE64( self, main ): |
| 1421 | """ |
| 1422 | Tests connectivity between two tagged hosts with different vlan id |
| 1423 | (Ports are configured as vlan-tagged 10 and 20, respectively) |
| 1424 | |
| 1425 | Sets up 1 ONOS instance |
| 1426 | Start 2x4 dual-homed leaf-spine topology |
| 1427 | Pingall |
| 1428 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1429 | try: |
| 1430 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1431 | except ImportError: |
| 1432 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1433 | main.cleanAndExit() |
| 1434 | try: |
| 1435 | main.funcs |
| 1436 | except ( NameError, AttributeError ): |
| 1437 | main.funcs = SRBridgingTest() |
| 1438 | main.funcs.runTest( main, |
| 1439 | test_idx=64, |
| 1440 | topology='2x4', |
| 1441 | onosNodes=1, |
| 1442 | description="Bridging test between two tagged hosts with different vlan id", |
| 1443 | vlan=[ 10, 20, 30, 40 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1444 | |
| 1445 | def CASE65( self, main ): |
| 1446 | """ |
| 1447 | Tests connectivity between two tagged hosts with different vlan id |
| 1448 | (Ports are configured as vlan-tagged 10 and 20, respectively) |
| 1449 | |
| 1450 | Sets up 3 ONOS instances |
| 1451 | Start 0x1 single ToR topology |
| 1452 | Pingall |
| 1453 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1454 | try: |
| 1455 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1456 | except ImportError: |
| 1457 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1458 | main.cleanAndExit() |
| 1459 | try: |
| 1460 | main.funcs |
| 1461 | except ( NameError, AttributeError ): |
| 1462 | main.funcs = SRBridgingTest() |
| 1463 | main.funcs.runTest( main, |
| 1464 | test_idx=65, |
| 1465 | topology='0x1', |
| 1466 | onosNodes=3, |
| 1467 | description="Bridging test between two tagged hosts with different vlan id", |
| 1468 | vlan=[ 10, 20 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1469 | |
| 1470 | def CASE66( self, main ): |
| 1471 | """ |
| 1472 | Tests connectivity between two tagged hosts with different vlan id |
| 1473 | (Ports are configured as vlan-tagged 10 and 20, respectively) |
| 1474 | |
| 1475 | Sets up 3 ONOS instances |
| 1476 | Start 0x2 dual-homed ToR topology |
| 1477 | Pingall |
| 1478 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1479 | try: |
| 1480 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1481 | except ImportError: |
| 1482 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1483 | main.cleanAndExit() |
| 1484 | try: |
| 1485 | main.funcs |
| 1486 | except ( NameError, AttributeError ): |
| 1487 | main.funcs = SRBridgingTest() |
| 1488 | main.funcs.runTest( main, |
| 1489 | test_idx=66, |
| 1490 | topology='0x2', |
| 1491 | onosNodes=3, |
| 1492 | description="Bridging test between two tagged hosts with different vlan id", |
| 1493 | vlan=[ 10, 20 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1494 | |
| 1495 | def CASE67( self, main ): |
| 1496 | """ |
| 1497 | Tests connectivity between two tagged hosts with different vlan id |
| 1498 | (Ports are configured as vlan-tagged 10 and 20, respectively) |
| 1499 | |
| 1500 | Sets up 3 ONOS instances |
| 1501 | Start 2x2 leaf-spine topology |
| 1502 | Pingall |
| 1503 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1504 | try: |
| 1505 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1506 | except ImportError: |
| 1507 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1508 | main.cleanAndExit() |
| 1509 | try: |
| 1510 | main.funcs |
| 1511 | except ( NameError, AttributeError ): |
| 1512 | main.funcs = SRBridgingTest() |
| 1513 | main.funcs.runTest( main, |
| 1514 | test_idx=67, |
| 1515 | topology='2x2', |
| 1516 | onosNodes=3, |
| 1517 | description="Bridging test between two tagged hosts with different vlan id", |
| 1518 | vlan=[ 10, 20, 30, 40 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1519 | |
| 1520 | def CASE68( self, main ): |
| 1521 | """ |
| 1522 | Tests connectivity between two tagged hosts with different vlan id |
| 1523 | (Ports are configured as vlan-tagged 10 and 20, respectively) |
| 1524 | |
| 1525 | Sets up 3 ONOS instances |
| 1526 | Start 2x4 dual-homed leaf-spine topology |
| 1527 | Pingall |
| 1528 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1529 | try: |
| 1530 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1531 | except ImportError: |
| 1532 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1533 | main.cleanAndExit() |
| 1534 | try: |
| 1535 | main.funcs |
| 1536 | except ( NameError, AttributeError ): |
| 1537 | main.funcs = SRBridgingTest() |
| 1538 | main.funcs.runTest( main, |
| 1539 | test_idx=68, |
| 1540 | topology='2x4', |
| 1541 | onosNodes=3, |
| 1542 | description="Bridging test between two tagged hosts with different vlan id", |
| 1543 | vlan=[ 10, 20, 30, 40 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1544 | |
| Siddesh | a19e3c8 | 2021-06-09 22:45:27 +0000 | [diff] [blame] | 1545 | def CASE69( self, main ): |
| 1546 | """ |
| 1547 | Tests connectivity between two tagged hosts with different vlan id |
| 1548 | (Ports are configured as vlan-tagged 10 and 20, respectively) |
| 1549 | |
| 1550 | Sets up 3 ONOS instances |
| 1551 | Start 2x2 leaf-spine topology |
| 1552 | Pingall |
| 1553 | """ |
| 1554 | try: |
| 1555 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1556 | except ImportError: |
| 1557 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1558 | main.cleanAndExit() |
| 1559 | try: |
| 1560 | main.funcs |
| 1561 | except ( NameError, AttributeError ): |
| 1562 | main.funcs = SRBridgingTest() |
| 1563 | main.funcs.runTest( main, |
| 1564 | test_idx=69, |
| 1565 | topology='2x2 dual-linked', |
| 1566 | onosNodes=3, |
| 1567 | description="Bridging test between two tagged hosts with different vlan id", |
| 1568 | vlan=[ 10, 20, 30, 40 ] ) |
| 1569 | |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1570 | def CASE71( self, main ): |
| 1571 | """ |
| 1572 | Tests connectivity between untagged and tagged hosts with different vlan id |
| 1573 | (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively) |
| 1574 | |
| 1575 | Sets up 1 ONOS instance |
| 1576 | Start 0x1 single ToR topology |
| 1577 | Pingall |
| 1578 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1579 | try: |
| 1580 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1581 | except ImportError: |
| 1582 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1583 | main.cleanAndExit() |
| 1584 | try: |
| 1585 | main.funcs |
| 1586 | except ( NameError, AttributeError ): |
| 1587 | main.funcs = SRBridgingTest() |
| 1588 | main.funcs.runTest( main, |
| 1589 | test_idx=71, |
| 1590 | topology='0x1', |
| 1591 | onosNodes=1, |
| 1592 | description="Bridging test between untagged and tagged hosts with different vlan id", |
| 1593 | vlan=[ 0, 20 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1594 | |
| 1595 | def CASE72( self, main ): |
| 1596 | """ |
| 1597 | Tests connectivity between untagged and tagged hosts with different vlan id |
| 1598 | (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively) |
| 1599 | |
| 1600 | Sets up 1 ONOS instance |
| 1601 | Start 0x2 dual-homed ToR topology |
| 1602 | Pingall |
| 1603 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1604 | try: |
| 1605 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1606 | except ImportError: |
| 1607 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1608 | main.cleanAndExit() |
| 1609 | try: |
| 1610 | main.funcs |
| 1611 | except ( NameError, AttributeError ): |
| 1612 | main.funcs = SRBridgingTest() |
| 1613 | main.funcs.runTest( main, |
| 1614 | test_idx=72, |
| 1615 | topology='0x2', |
| 1616 | onosNodes=1, |
| 1617 | description="Bridging test between untagged and tagged hosts with different vlan id", |
| 1618 | vlan=[ 0, 20 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1619 | |
| 1620 | def CASE73( self, main ): |
| 1621 | """ |
| 1622 | Tests connectivity between untagged and tagged hosts with different vlan id |
| 1623 | (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively) |
| 1624 | |
| 1625 | Sets up 1 ONOS instance |
| 1626 | Start 2x2 leaf-spine topology |
| 1627 | Pingall |
| 1628 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1629 | try: |
| 1630 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1631 | except ImportError: |
| 1632 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1633 | main.cleanAndExit() |
| 1634 | try: |
| 1635 | main.funcs |
| 1636 | except ( NameError, AttributeError ): |
| 1637 | main.funcs = SRBridgingTest() |
| 1638 | main.funcs.runTest( main, |
| 1639 | test_idx=73, |
| 1640 | topology='2x2', |
| 1641 | onosNodes=1, |
| 1642 | description="Bridging test between untagged and tagged hosts with different vlan id", |
| 1643 | vlan=[ 0, 20, 0, 40 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1644 | |
| 1645 | def CASE74( self, main ): |
| 1646 | """ |
| 1647 | Tests connectivity between untagged and tagged hosts with different vlan id |
| 1648 | (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively) |
| 1649 | |
| 1650 | Sets up 1 ONOS instance |
| 1651 | Start 2x2 dual-homed leaf-spine topology |
| 1652 | Pingall |
| 1653 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1654 | try: |
| 1655 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1656 | except ImportError: |
| 1657 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1658 | main.cleanAndExit() |
| 1659 | try: |
| 1660 | main.funcs |
| 1661 | except ( NameError, AttributeError ): |
| 1662 | main.funcs = SRBridgingTest() |
| 1663 | main.funcs.runTest( main, |
| 1664 | test_idx=74, |
| 1665 | topology='2x4', |
| 1666 | onosNodes=1, |
| 1667 | description="Bridging test between untagged and tagged hosts with different vlan id", |
| 1668 | vlan=[ 0, 20, 0, 40 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1669 | |
| 1670 | def CASE75( self, main ): |
| 1671 | """ |
| 1672 | Tests connectivity between untagged and tagged hosts with different vlan id |
| 1673 | (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively) |
| 1674 | |
| 1675 | Sets up 3 ONOS instances |
| 1676 | Start 0x1 single ToR topology |
| 1677 | Pingall |
| 1678 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1679 | try: |
| 1680 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1681 | except ImportError: |
| 1682 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1683 | main.cleanAndExit() |
| 1684 | try: |
| 1685 | main.funcs |
| 1686 | except ( NameError, AttributeError ): |
| 1687 | main.funcs = SRBridgingTest() |
| 1688 | main.funcs.runTest( main, |
| 1689 | test_idx=75, |
| 1690 | topology='0x1', |
| 1691 | onosNodes=3, |
| 1692 | description="Bridging test between untagged and tagged hosts with different vlan id", |
| 1693 | vlan=[ 0, 20 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1694 | |
| 1695 | def CASE76( self, main ): |
| 1696 | """ |
| 1697 | Tests connectivity between untagged and tagged hosts with different vlan id |
| 1698 | (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively) |
| 1699 | |
| 1700 | Sets up 3 ONOS instances |
| 1701 | Start 0x2 dual-homed ToR topology |
| 1702 | Pingall |
| 1703 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1704 | try: |
| 1705 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1706 | except ImportError: |
| 1707 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1708 | main.cleanAndExit() |
| 1709 | try: |
| 1710 | main.funcs |
| 1711 | except ( NameError, AttributeError ): |
| 1712 | main.funcs = SRBridgingTest() |
| 1713 | main.funcs.runTest( main, |
| 1714 | test_idx=76, |
| 1715 | topology='0x2', |
| 1716 | onosNodes=3, |
| 1717 | description="Bridging test between untagged and tagged hosts with different vlan id", |
| 1718 | vlan=[ 0, 20 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1719 | |
| 1720 | def CASE77( self, main ): |
| 1721 | """ |
| 1722 | Tests connectivity between untagged and tagged hosts with different vlan id |
| 1723 | (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively) |
| 1724 | |
| 1725 | Sets up 3 ONOS instances |
| 1726 | Start 2x2 leaf-spine topology |
| 1727 | Pingall |
| 1728 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1729 | try: |
| 1730 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1731 | except ImportError: |
| 1732 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1733 | main.cleanAndExit() |
| 1734 | try: |
| 1735 | main.funcs |
| 1736 | except ( NameError, AttributeError ): |
| 1737 | main.funcs = SRBridgingTest() |
| 1738 | main.funcs.runTest( main, |
| 1739 | test_idx=77, |
| 1740 | topology='2x2', |
| 1741 | onosNodes=3, |
| 1742 | description="Bridging test between untagged and tagged hosts with different vlan id", |
| 1743 | vlan=[ 0, 20, 0, 40 ] ) |
| Jonghwan Hyun | 3731d6a | 2017-10-19 11:59:31 -0700 | [diff] [blame] | 1744 | |
| 1745 | def CASE78( self, main ): |
| 1746 | """ |
| 1747 | Tests connectivity between untagged and tagged hosts with different vlan id |
| 1748 | (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively) |
| 1749 | |
| 1750 | Sets up 3 ONOS instances |
| 1751 | Start 2x2 dual-homed leaf-spine topology |
| 1752 | Pingall |
| 1753 | """ |
| Devin Lim | 57221b0 | 2018-02-14 15:45:36 -0800 | [diff] [blame] | 1754 | try: |
| 1755 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1756 | except ImportError: |
| 1757 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1758 | main.cleanAndExit() |
| 1759 | try: |
| 1760 | main.funcs |
| 1761 | except ( NameError, AttributeError ): |
| 1762 | main.funcs = SRBridgingTest() |
| 1763 | main.funcs.runTest( main, |
| 1764 | test_idx=78, |
| 1765 | topology='2x4', |
| 1766 | onosNodes=3, |
| 1767 | description="Bridging test between untagged and tagged hosts with different vlan id", |
| 1768 | vlan=[ 0, 20, 0, 40 ] ) |
| Siddesh | a19e3c8 | 2021-06-09 22:45:27 +0000 | [diff] [blame] | 1769 | |
| 1770 | def CASE79( self, main ): |
| 1771 | """ |
| 1772 | Tests connectivity between untagged and tagged hosts with different vlan id |
| 1773 | (Ports are configured as vlan-untagged 10 and vlan-tagged 20, respectively) |
| 1774 | |
| 1775 | Sets up 3 ONOS instances |
| 1776 | Start 2x2 leaf-spine topology |
| 1777 | Pingall |
| 1778 | """ |
| 1779 | try: |
| 1780 | from tests.USECASE.SegmentRouting.SRBridging.dependencies.SRBridgingTest import SRBridgingTest |
| 1781 | except ImportError: |
| 1782 | main.log.error( "SRBridgingTest not found. Exiting the test" ) |
| 1783 | main.cleanAndExit() |
| 1784 | try: |
| 1785 | main.funcs |
| 1786 | except ( NameError, AttributeError ): |
| 1787 | main.funcs = SRBridgingTest() |
| 1788 | main.funcs.runTest( main, |
| 1789 | test_idx=79, |
| 1790 | topology='2x2 dual-linked', |
| 1791 | onosNodes=3, |
| 1792 | description="Bridging test between untagged and tagged hosts with different vlan idt", |
| 1793 | vlan=[ 0, 20, 0, 40 ] ) |