test/asf/test_quic.py

   1 #!/usr/bin/env python3
   2 """ Vpp QUIC tests """
   3
   4 import unittest
   5 import os
   6 import subprocess
   7 import signal
   8 from config import config
   9 from framework import tag_fixme_vpp_workers
  10 from framework import VppTestCase, VppTestRunner, Worker
  11 from vpp_ip_route import VppIpTable, VppIpRoute, VppRoutePath
  12
  13
  14 class QUICAppWorker(Worker):
  15     """QUIC Test Application Worker"""
  16
  17     process = None
  18
  19     def __init__(
  20         self,
  21         appname,
  22         executable_args,
  23         logger,
  24         role,
  25         testcase,
  26         env=None,
  27         *args,
  28         **kwargs,
  29     ):
  30         if env is None:
  31             env = {}
  32         app = f"{config.vpp_build_dir}/vpp/bin/{appname}"
  33         self.args = [app] + executable_args
  34         self.role = role
  35         self.wait_for_gdb = "wait-for-gdb"
  36         self.testcase = testcase
  37         super(QUICAppWorker, self).__init__(self.args, logger, env, *args, **kwargs)
  38
  39     def run(self):
  40         super(QUICAppWorker, self).run()
  41
  42     def teardown(self, logger, timeout):
  43         if self.process is None:
  44             return False
  45         try:
  46             logger.debug(f"Killing worker process (pid {self.process.pid})")
  47             os.killpg(os.getpgid(self.process.pid), signal.SIGKILL)
  48             self.join(timeout)
  49         except OSError as e:
  50             logger.debug("Couldn't kill worker process")
  51             return True
  52         return False
  53
  54
  55 class QUICTestCase(VppTestCase):
  56     """QUIC Test Case"""
  57
  58     timeout = 20
  59     pre_test_sleep = 0.3
  60     post_test_sleep = 0.3
  61     server_appns = "server"
  62     server_appns_secret = None
  63     client_appns = "client"
  64     client_appns_secret = None
  65
  66     @classmethod
  67     def setUpClass(cls):
  68         cls.extra_vpp_plugin_config.append("plugin quic_plugin.so { enable }")
  69         super(QUICTestCase, cls).setUpClass()
  70
  71     def setUp(self):
  72         super(QUICTestCase, self).setUp()
  73         self.vppDebug = "vpp_debug" in config.vpp_build_dir
  74
  75         self.create_loopback_interfaces(2)
  76         self.uri = f"quic://{self.loop0.local_ip4}/1234"
  77         table_id = 1
  78         for i in self.lo_interfaces:
  79             i.admin_up()
  80
  81             if table_id != 0:
  82                 tbl = VppIpTable(self, table_id)
  83                 tbl.add_vpp_config()
  84
  85             i.set_table_ip4(table_id)
  86             i.config_ip4()
  87             table_id += 1
  88
  89         # Configure namespaces
  90         self.vapi.app_namespace_add_del_v4(
  91             namespace_id=self.server_appns,
  92             secret=self.server_appns_secret,
  93             sw_if_index=self.loop0.sw_if_index,
  94         )
  95         self.vapi.app_namespace_add_del_v4(
  96             namespace_id=self.client_appns,
  97             secret=self.client_appns_secret,
  98             sw_if_index=self.loop1.sw_if_index,
  99         )
 100
 101         # Add inter-table routes
 102         self.ip_t01 = VppIpRoute(
 103             self,
 104             self.loop1.local_ip4,
 105             32,
 106             [VppRoutePath("0.0.0.0", 0xFFFFFFFF, nh_table_id=2)],
 107             table_id=1,
 108         )
 109         self.ip_t10 = VppIpRoute(
 110             self,
 111             self.loop0.local_ip4,
 112             32,
 113             [VppRoutePath("0.0.0.0", 0xFFFFFFFF, nh_table_id=1)],
 114             table_id=2,
 115         )
 116         self.ip_t01.add_vpp_config()
 117         self.ip_t10.add_vpp_config()
 118         self.logger.debug(self.vapi.cli("show ip fib"))
 119
 120     def tearDown(self):
 121         # Delete inter-table routes
 122         self.ip_t01.remove_vpp_config()
 123         self.ip_t10.remove_vpp_config()
 124
 125         for i in self.lo_interfaces:
 126             i.unconfig_ip4()
 127             i.set_table_ip4(0)
 128             i.admin_down()
 129         super(QUICTestCase, self).tearDown()
 130
 131
 132 class QUICEchoIntTestCase(QUICTestCase):
 133     """QUIC Echo Internal Test Case"""
 134
 135     test_bytes = " test-bytes"
 136     extra_vpp_config = ["session", "{", "enable", "poll-main", "}"]
 137
 138     def setUp(self):
 139         super(QUICEchoIntTestCase, self).setUp()
 140         self.client_args = (
 141             f"uri {self.uri} fifo-size 64{self.test_bytes} appns {self.client_appns} "
 142         )
 143         self.server_args = f"uri {self.uri} fifo-size 64 appns {self.server_appns} "
 144
 145     def tearDown(self):
 146         super(QUICEchoIntTestCase, self).tearDown()
 147
 148     def server(self, *args):
 149         _args = self.server_args + " ".join(args)
 150         error = self.vapi.cli(f"test echo server {_args}")
 151         if error:
 152             self.logger.critical(error)
 153             self.assertNotIn("failed", error)
 154
 155     def client(self, *args):
 156         _args = self.client_args + " ".join(args)
 157         error = self.vapi.cli(f"test echo client {_args}")
 158         if error:
 159             self.logger.critical(error)
 160             self.assertNotIn("failed", error)
 161
 162
 163 @tag_fixme_vpp_workers
 164 class QUICEchoIntTransferTestCase(QUICEchoIntTestCase):
 165     """QUIC Echo Internal Transfer Test Case"""
 166
 167     def test_quic_int_transfer(self):
 168         """QUIC internal transfer"""
 169         self.server()
 170         self.client("no-output", "mbytes", "2")
 171
 172
 173 @tag_fixme_vpp_workers
 174 class QUICEchoIntSerialTestCase(QUICEchoIntTestCase):
 175     """QUIC Echo Internal Serial Transfer Test Case"""
 176
 177     def test_quic_serial_int_transfer(self):
 178         """QUIC serial internal transfer"""
 179         self.server()
 180         self.client("no-output", "mbytes", "2")
 181         self.client("no-output", "mbytes", "2")
 182         self.client("no-output", "mbytes", "2")
 183         self.client("no-output", "mbytes", "2")
 184         self.client("no-output", "mbytes", "2")
 185
 186
 187 @tag_fixme_vpp_workers
 188 class QUICEchoIntMStreamTestCase(QUICEchoIntTestCase):
 189     """QUIC Echo Internal MultiStream Test Case"""
 190
 191     def test_quic_int_multistream_transfer(self):
 192         """QUIC internal multi-stream transfer"""
 193         self.server()
 194         self.client("nclients", "10", "mbytes", "1", "no-output")
 195
 196
 197 class QUICEchoExtTestCase(QUICTestCase):
 198     quic_setup = "default"
 199     test_bytes = "test-bytes:assert"
 200     pre_test_sleep = 1
 201     post_test_sleep = 1
 202     app = "vpp_echo"
 203     evt_q_len = 16384
 204     vpp_worker_count = 1
 205     server_fifo_size = "1M"
 206     client_fifo_size = "4M"
 207     extra_vpp_config = [
 208         "session",
 209         "{",
 210         "enable",
 211         "poll-main",
 212         "use-app-socket-api",
 213         "wrk-mqs-segment-size",
 214         "64M",
 215         "event-queue-length",
 216         f"{evt_q_len}",
 217         "preallocated-sessions",
 218         "1024",
 219         "v4-session-table-buckets",
 220         "20000",
 221         "v4-session-table-memory",
 222         "64M",
 223         "v4-halfopen-table-buckets",
 224         "20000",
 225         "v4-halfopen-table-memory",
 226         "64M",
 227         "local-endpoints-table-buckets",
 228         "250000",
 229         "local-endpoints-table-memory",
 230         "512M",
 231         "}",
 232     ]
 233
 234     def setUp(self):
 235         self.server_appns_secret = 1234
 236         self.client_appns_secret = 5678
 237         super(QUICEchoExtTestCase, self).setUp()
 238         common_args = [
 239             "uri",
 240             self.uri,
 241             "json",
 242             self.test_bytes,
 243             "quic-setup",
 244             self.quic_setup,
 245             "nthreads",
 246             "1",
 247             "mq-size",
 248             f"{self.evt_q_len}",
 249             "use-app-socket-api",
 250         ]
 251         self.server_echo_test_args = common_args + [
 252             "server",
 253             "appns",
 254             f"{self.server_appns}",
 255             "fifo-size",
 256             f"{self.server_fifo_size}",
 257             "socket-name",
 258             f"{self.tempdir}/app_ns_sockets/{self.server_appns}",
 259         ]
 260         self.client_echo_test_args = common_args + [
 261             "client",
 262             "appns",
 263             f"{self.client_appns}",
 264             "fifo-size",
 265             f"{self.client_fifo_size}",
 266             "socket-name",
 267             f"{self.tempdir}/app_ns_sockets/{self.client_appns}",
 268         ]
 269         error = self.vapi.cli("quic set fifo-size 2M")
 270         if error:
 271             self.logger.critical(error)
 272             self.assertNotIn("failed", error)
 273
 274     def server(self, *args):
 275         _args = self.server_echo_test_args + list(args)
 276         self.worker_server = QUICAppWorker(
 277             self.app, _args, self.logger, self.server_appns, self
 278         )
 279         self.worker_server.start()
 280         self.sleep(self.pre_test_sleep)
 281
 282     def client(self, *args):
 283         _args = self.client_echo_test_args + list(args)
 284         self.worker_client = QUICAppWorker(
 285             self.app, _args, self.logger, self.client_appns, self
 286         )
 287         self.worker_client.start()
 288         timeout = None if self.debug_all else self.timeout
 289         self.worker_client.join(timeout)
 290         if self.worker_client.is_alive():
 291             error = f"Client failed to complete in {timeout} seconds!"
 292             self.logger.critical(error)
 293             return
 294         self.worker_server.join(timeout)
 295         if self.worker_server.is_alive():
 296             error = f"Server failed to complete in {timeout} seconds!"
 297             self.logger.critical(error)
 298         self.sleep(self.post_test_sleep)
 299
 300     def validate_ext_test_results(self):
 301         server_result = self.worker_server.result
 302         self.logger.debug(self.vapi.cli(f"show session verbose 2"))
 303         client_result = self.worker_client.result
 304         self.logger.info(f"Server worker result is `{server_result}'")
 305         self.logger.info(f"Client worker result is `{client_result}'")
 306         server_kill_error = False
 307         if self.worker_server.result is None:
 308             server_kill_error = self.worker_server.teardown(self.logger, self.timeout)
 309         if self.worker_client.result is None:
 310             self.worker_client.teardown(self.logger, self.timeout)
 311         err_msg = f"Wrong server worker return code ({server_result})"
 312         self.assertEqual(server_result, 0, err_msg)
 313         self.assertIsNotNone(
 314             client_result, f"Timeout! Client worker did not finish in {self.timeout}s"
 315         )
 316         err_msg = f"Wrong client worker return code ({client_result})"
 317         self.assertEqual(client_result, 0, err_msg)
 318         self.assertFalse(server_kill_error, "Server kill errored")
 319
 320
 321 class QUICEchoExtTransferTestCase(QUICEchoExtTestCase):
 322     """QUIC Echo External Transfer Test Case"""
 323
 324     timeout = 60
 325
 326     def test_quic_ext_transfer(self):
 327         """QUIC external transfer"""
 328         self.server()
 329         self.client()
 330         self.validate_ext_test_results()
 331
 332
 333 class QUICEchoExtTransferBigTestCase(QUICEchoExtTestCase):
 334     """QUIC Echo External Transfer Big Test Case"""
 335
 336     server_fifo_size = "4M"
 337     client_fifo_size = "4M"
 338     test_bytes = ""
 339     timeout = 60
 340
 341     @unittest.skipUnless(config.extended, "part of extended tests")
 342     def test_quic_ext_transfer_big(self):
 343         """QUIC external transfer, big stream"""
 344         self.server("TX=0", "RX=2G")
 345         self.client("TX=2G", "RX=0")
 346         self.validate_ext_test_results()
 347
 348
 349 class QUICEchoExtQcloseRxTestCase(QUICEchoExtTestCase):
 350     """QUIC Echo External Transfer Qclose Rx Test Case"""
 351
 352     @unittest.skipUnless(config.extended, "part of extended tests")
 353     @unittest.skip("testcase under development")
 354     def test_quic_ext_qclose_rx(self):
 355         """QUIC external transfer, rx close"""
 356         self.server("TX=0", "RX=10M", "qclose=Y", "sclose=N")
 357         self.client("TX=10M", "RX=0", "qclose=W", "sclose=W")
 358         self.validate_ext_test_results()
 359
 360
 361 class QUICEchoExtQcloseTxTestCase(QUICEchoExtTestCase):
 362     """QUIC Echo External Transfer Qclose Tx Test Case"""
 363
 364     @unittest.skipUnless(config.extended, "part of extended tests")
 365     @unittest.skip("testcase under development")
 366     def test_quic_ext_qclose_tx(self):
 367         """QUIC external transfer, tx close"""
 368         self.server("TX=0", "RX=10M", "qclose=W", "sclose=W", "rx-results-diff")
 369         self.client("TX=10M", "RX=0", "qclose=Y", "sclose=N")
 370         self.validate_ext_test_results()
 371
 372
 373 class QUICEchoExtEarlyQcloseRxTestCase(QUICEchoExtTestCase):
 374     """QUIC Echo External Transfer Early Qclose Rx Test Case"""
 375
 376     @unittest.skipUnless(config.extended, "part of extended tests")
 377     @unittest.skip("testcase under development")
 378     def test_quic_ext_early_qclose_rx(self):
 379         """QUIC external transfer, early rx close"""
 380         self.server("TX=0", "RX=10M", "qclose=Y", "sclose=N")
 381         self.client("TX=20M", "RX=0", "qclose=W", "sclose=W", "tx-results-diff")
 382         self.validate_ext_test_results()
 383
 384
 385 class QUICEchoExtEarlyQcloseTxTestCase(QUICEchoExtTestCase):
 386     """QUIC Echo External Transfer Early Qclose Tx Test Case"""
 387
 388     @unittest.skipUnless(config.extended, "part of extended tests")
 389     @unittest.skip("testcase under development")
 390     def test_quic_ext_early_qclose_tx(self):
 391         """QUIC external transfer, early tx close"""
 392         self.server("TX=0", "RX=20M", "qclose=W", "sclose=W", "rx-results-diff")
 393         self.client("TX=10M", "RX=0", "qclose=Y", "sclose=N")
 394         self.validate_ext_test_results()
 395
 396
 397 class QUICEchoExtScloseRxTestCase(QUICEchoExtTestCase):
 398     """QUIC Echo External Transfer Sclose Rx Test Case"""
 399
 400     @unittest.skipUnless(config.extended, "part of extended tests")
 401     @unittest.skip("testcase under development")
 402     def test_quic_ext_sclose_rx(self):
 403         """QUIC external transfer, rx stream close"""
 404         self.server("TX=0", "RX=10M", "qclose=N", "sclose=Y")
 405         self.client("TX=10M", "RX=0", "qclose=W", "sclose=W")
 406         self.validate_ext_test_results()
 407
 408
 409 class QUICEchoExtScloseTxTestCase(QUICEchoExtTestCase):
 410     """QUIC Echo External Transfer Sclose Tx Test Case"""
 411
 412     @unittest.skipUnless(config.extended, "part of extended tests")
 413     @unittest.skip("testcase under development")
 414     def test_quic_ext_sclose_tx(self):
 415         """QUIC external transfer, tx stream close"""
 416         self.server("TX=0", "RX=10M", "qclose=W", "sclose=W")
 417         self.client("TX=10M", "RX=0", "qclose=Y", "sclose=Y")
 418         self.validate_ext_test_results()
 419
 420
 421 class QUICEchoExtEarlyScloseRxTestCase(QUICEchoExtTestCase):
 422     """QUIC Echo External Transfer Early Sclose Rx Test Case"""
 423
 424     @unittest.skipUnless(config.extended, "part of extended tests")
 425     @unittest.skip("testcase under development")
 426     def test_quic_ext_early_sclose_rx(self):
 427         """QUIC external transfer, early rx stream close"""
 428         self.server("TX=0", "RX=10M", "qclose=N", "sclose=Y")
 429         self.client("TX=20M", "RX=0", "qclose=W", "sclose=W", "tx-results-diff")
 430         self.validate_ext_test_results()
 431
 432
 433 class QUICEchoExtEarlyScloseTxTestCase(QUICEchoExtTestCase):
 434     """QUIC Echo External Transfer Early Sclose Tx Test Case"""
 435
 436     @unittest.skipUnless(config.extended, "part of extended tests")
 437     @unittest.skip("testcase under development")
 438     def test_quic_ext_early_sclose_tx(self):
 439         """QUIC external transfer, early tx stream close"""
 440         self.server("TX=0", "RX=20M", "qclose=W", "sclose=W", "rx-results-diff")
 441         self.client("TX=10M", "RX=0", "qclose=Y", "sclose=Y")
 442         self.validate_ext_test_results()
 443
 444
 445 class QUICEchoExtServerStreamTestCase(QUICEchoExtTestCase):
 446     """QUIC Echo External Transfer Server Stream Test Case"""
 447
 448     quic_setup = "serverstream"
 449     timeout = 60
 450
 451     def test_quic_ext_transfer_server_stream(self):
 452         """QUIC external server transfer"""
 453         self.server("TX=10M", "RX=0")
 454         self.client("TX=0", "RX=10M")
 455         self.validate_ext_test_results()
 456
 457
 458 class QUICEchoExtServerStreamBigTestCase(QUICEchoExtTestCase):
 459     """QUIC Echo External Transfer Server Stream Big Test Case"""
 460
 461     quic_setup = "serverstream"
 462     server_fifo_size = "4M"
 463     client_fifo_size = "4M"
 464     test_bytes = ""
 465     timeout = 60
 466
 467     @unittest.skipUnless(config.extended, "part of extended tests")
 468     def test_quic_ext_transfer_server_stream_big(self):
 469         """QUIC external server transfer, big stream"""
 470         self.server("TX=2G", "RX=0")
 471         self.client("TX=0", "RX=2G")
 472         self.validate_ext_test_results()
 473
 474
 475 class QUICEchoExtServerStreamQcloseRxTestCase(QUICEchoExtTestCase):
 476     """QUIC Echo External Transfer Server Stream Qclose Rx Test Case"""
 477
 478     quic_setup = "serverstream"
 479
 480     @unittest.skipUnless(config.extended, "part of extended tests")
 481     @unittest.skip("testcase under development")
 482     def test_quic_ext_server_stream_qclose_rx(self):
 483         """QUIC external server transfer, rx close"""
 484         self.server("TX=10M", "RX=0", "qclose=W", "sclose=W")
 485         self.client("TX=0", "RX=10M", "qclose=Y", "sclose=N")
 486         self.validate_ext_test_results()
 487
 488
 489 class QUICEchoExtServerStreamQcloseTxTestCase(QUICEchoExtTestCase):
 490     """QUIC Echo External Transfer Server Stream Qclose Tx Test Case"""
 491
 492     quic_setup = "serverstream"
 493
 494     @unittest.skipUnless(config.extended, "part of extended tests")
 495     @unittest.skip("testcase under development")
 496     def test_quic_ext_server_stream_qclose_tx(self):
 497         """QUIC external server transfer, tx close"""
 498         self.server("TX=10M", "RX=0", "qclose=Y", "sclose=N")
 499         self.client("TX=0", "RX=10M", "qclose=W", "sclose=W", "rx-results-diff")
 500         self.validate_ext_test_results()
 501
 502
 503 class QUICEchoExtServerStreamEarlyQcloseRxTestCase(QUICEchoExtTestCase):
 504     """QUIC Echo External Transfer Server Stream Early Qclose Rx Test Case"""
 505
 506     quic_setup = "serverstream"
 507
 508     @unittest.skipUnless(config.extended, "part of extended tests")
 509     @unittest.skip("testcase under development")
 510     def test_quic_ext_server_stream_early_qclose_rx(self):
 511         """QUIC external server transfer, early rx close"""
 512         self.server("TX=20M", "RX=0", "qclose=W", "sclose=W", "tx-results-diff")
 513         self.client("TX=0", "RX=10M", "qclose=Y", "sclose=N")
 514         self.validate_ext_test_results()
 515
 516
 517 class QUICEchoExtServerStreamEarlyQcloseTxTestCase(QUICEchoExtTestCase):
 518     """QUIC Echo External Transfer Server Stream Early Qclose Tx Test Case"""
 519
 520     quic_setup = "serverstream"
 521
 522     @unittest.skipUnless(config.extended, "part of extended tests")
 523     @unittest.skip("testcase under development")
 524     def test_quic_ext_server_stream_early_qclose_tx(self):
 525         """QUIC external server transfer, early tx close"""
 526         self.server("TX=10M", "RX=0", "qclose=Y", "sclose=N")
 527         self.client("TX=0", "RX=20M", "qclose=W", "sclose=W", "rx-results-diff")
 528         self.validate_ext_test_results()
 529
 530
 531 class QUICEchoExtServerStreamScloseRxTestCase(QUICEchoExtTestCase):
 532     """QUIC Echo External Transfer Server Stream Sclose Rx Test Case"""
 533
 534     quic_setup = "serverstream"
 535
 536     @unittest.skipUnless(config.extended, "part of extended tests")
 537     @unittest.skip("testcase under development")
 538     def test_quic_ext_server_stream_sclose_rx(self):
 539         """QUIC external server transfer, rx stream close"""
 540         self.server("TX=10M", "RX=0", "qclose=W", "sclose=W")
 541         self.client("TX=0", "RX=10M", "qclose=N", "sclose=Y")
 542         self.validate_ext_test_results()
 543
 544
 545 class QUICEchoExtServerStreamScloseTxTestCase(QUICEchoExtTestCase):
 546     """QUIC Echo External Transfer Server Stream Sclose Tx Test Case"""
 547
 548     quic_setup = "serverstream"
 549
 550     @unittest.skipUnless(config.extended, "part of extended tests")
 551     @unittest.skip("testcase under development")
 552     def test_quic_ext_server_stream_sclose_tx(self):
 553         """QUIC external server transfer, tx stream close"""
 554         self.server("TX=10M", "RX=0", "qclose=Y", "sclose=Y")
 555         self.client("TX=0", "RX=10M", "qclose=W", "sclose=W")
 556         self.validate_ext_test_results()
 557
 558
 559 class QUICEchoExtServerStreamEarlyScloseRxTestCase(QUICEchoExtTestCase):
 560     """QUIC Echo External Transfer Server Stream Early Sclose Rx Test Case"""
 561
 562     quic_setup = "serverstream"
 563
 564     @unittest.skipUnless(config.extended, "part of extended tests")
 565     @unittest.skip("testcase under development")
 566     def test_quic_ext_server_stream_early_sclose_rx(self):
 567         """QUIC external server transfer, early rx stream close"""
 568         self.server("TX=20M", "RX=0", "qclose=W", "sclose=W", "tx-results-diff")
 569         self.client("TX=0", "RX=10M", "qclose=N", "sclose=Y")
 570         self.validate_ext_test_results()
 571
 572
 573 class QUICEchoExtServerStreamEarlyScloseTxTestCase(QUICEchoExtTestCase):
 574     """QUIC Echo Ext Transfer Server Stream Early Sclose Tx Test Case"""
 575
 576     quic_setup = "serverstream"
 577
 578     @unittest.skipUnless(config.extended, "part of extended tests")
 579     @unittest.skip("testcase under development")
 580     def test_quic_ext_server_stream_early_sclose_tx(self):
 581         """QUIC external server transfer, early tx stream close"""
 582         self.server("TX=10M", "RX=0", "qclose=Y", "sclose=Y")
 583         self.client("TX=0", "RX=20M", "qclose=W", "sclose=W", "rx-results-diff")
 584         self.validate_ext_test_results()
 585
 586
 587 class QUICEchoExtServerStreamWorkersTestCase(QUICEchoExtTestCase):
 588     """QUIC Echo External Transfer Server Stream MultiWorker Test Case"""
 589
 590     quic_setup = "serverstream"
 591
 592     @unittest.skipUnless(config.extended, "part of extended tests")
 593     @unittest.skip("testcase under development")
 594     def test_quic_ext_transfer_server_stream_multi_workers(self):
 595         """QUIC external server transfer, multi-worker"""
 596         self.server("nclients", "4", "quic-streams", "4", "TX=10M", "RX=0")
 597         self.client("nclients", "4", "quic-streams", "4", "TX=0", "RX=10M")
 598         self.validate_ext_test_results()
 599
 600
 601 if __name__ == "__main__":
 602     unittest.main(testRunner=VppTestRunner)