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(
  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(
  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_punt_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_punt_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         client_result = self.worker_client.result
 303         self.logger.info(f"Server worker result is `{server_result}'")
 304         self.logger.info(f"Client worker result is `{client_result}'")
 305         server_kill_error = False
 306         if self.worker_server.result is None:
 307             server_kill_error = self.worker_server.teardown(self.logger, self.timeout)
 308         if self.worker_client.result is None:
 309             self.worker_client.teardown(self.logger, self.timeout)
 310         err_msg = f"Wrong server worker return code ({server_result})"
 311         self.assertEqual(server_result, 0, err_msg)
 312         self.assertIsNotNone(
 313             client_result, f"Timeout! Client worker did not finish in {self.timeout}s"
 314         )
 315         err_msg = f"Wrong client worker return code ({client_result})"
 316         self.assertEqual(client_result, 0, err_msg)
 317         self.assertFalse(server_kill_error, "Server kill errored")
 318
 319
 320 class QUICEchoExtTransferTestCase(QUICEchoExtTestCase):
 321     """QUIC Echo External Transfer Test Case"""
 322
 323     timeout = 60
 324
 325     def test_quic_ext_transfer(self):
 326         """QUIC external transfer"""
 327         self.server()
 328         self.client()
 329         self.validate_ext_test_results()
 330
 331
 332 class QUICEchoExtTransferBigTestCase(QUICEchoExtTestCase):
 333     """QUIC Echo External Transfer Big Test Case"""
 334
 335     server_fifo_size = "4M"
 336     client_fifo_size = "4M"
 337     test_bytes = ""
 338     timeout = 60
 339
 340     @unittest.skipUnless(config.extended, "part of extended tests")
 341     def test_quic_ext_transfer_big(self):
 342         """QUIC external transfer, big stream"""
 343         self.server("TX=0", "RX=2G")
 344         self.client("TX=2G", "RX=0")
 345         self.validate_ext_test_results()
 346
 347
 348 class QUICEchoExtQcloseRxTestCase(QUICEchoExtTestCase):
 349     """QUIC Echo External Transfer Qclose Rx Test Case"""
 350
 351     @unittest.skipUnless(config.extended, "part of extended tests")
 352     @unittest.skip("testcase under development")
 353     def test_quic_ext_qclose_rx(self):
 354         """QUIC external transfer, rx close"""
 355         self.server("TX=0", "RX=10M", "qclose=Y", "sclose=N")
 356         self.client("TX=10M", "RX=0", "qclose=W", "sclose=W")
 357         self.validate_ext_test_results()
 358
 359
 360 class QUICEchoExtQcloseTxTestCase(QUICEchoExtTestCase):
 361     """QUIC Echo External Transfer Qclose Tx Test Case"""
 362
 363     @unittest.skipUnless(config.extended, "part of extended tests")
 364     @unittest.skip("testcase under development")
 365     def test_quic_ext_qclose_tx(self):
 366         """QUIC external transfer, tx close"""
 367         self.server("TX=0", "RX=10M", "qclose=W", "sclose=W", "rx-results-diff")
 368         self.client("TX=10M", "RX=0", "qclose=Y", "sclose=N")
 369         self.validate_ext_test_results()
 370
 371
 372 class QUICEchoExtEarlyQcloseRxTestCase(QUICEchoExtTestCase):
 373     """QUIC Echo External Transfer Early Qclose Rx Test Case"""
 374
 375     @unittest.skipUnless(config.extended, "part of extended tests")
 376     @unittest.skip("testcase under development")
 377     def test_quic_ext_early_qclose_rx(self):
 378         """QUIC external transfer, early rx close"""
 379         self.server("TX=0", "RX=10M", "qclose=Y", "sclose=N")
 380         self.client("TX=20M", "RX=0", "qclose=W", "sclose=W", "tx-results-diff")
 381         self.validate_ext_test_results()
 382
 383
 384 class QUICEchoExtEarlyQcloseTxTestCase(QUICEchoExtTestCase):
 385     """QUIC Echo External Transfer Early Qclose Tx Test Case"""
 386
 387     @unittest.skipUnless(config.extended, "part of extended tests")
 388     @unittest.skip("testcase under development")
 389     def test_quic_ext_early_qclose_tx(self):
 390         """QUIC external transfer, early tx close"""
 391         self.server("TX=0", "RX=20M", "qclose=W", "sclose=W", "rx-results-diff")
 392         self.client("TX=10M", "RX=0", "qclose=Y", "sclose=N")
 393         self.validate_ext_test_results()
 394
 395
 396 class QUICEchoExtScloseRxTestCase(QUICEchoExtTestCase):
 397     """QUIC Echo External Transfer Sclose Rx Test Case"""
 398
 399     @unittest.skipUnless(config.extended, "part of extended tests")
 400     @unittest.skip("testcase under development")
 401     def test_quic_ext_sclose_rx(self):
 402         """QUIC external transfer, rx stream close"""
 403         self.server("TX=0", "RX=10M", "qclose=N", "sclose=Y")
 404         self.client("TX=10M", "RX=0", "qclose=W", "sclose=W")
 405         self.validate_ext_test_results()
 406
 407
 408 class QUICEchoExtScloseTxTestCase(QUICEchoExtTestCase):
 409     """QUIC Echo External Transfer Sclose Tx Test Case"""
 410
 411     @unittest.skipUnless(config.extended, "part of extended tests")
 412     @unittest.skip("testcase under development")
 413     def test_quic_ext_sclose_tx(self):
 414         """QUIC external transfer, tx stream close"""
 415         self.server("TX=0", "RX=10M", "qclose=W", "sclose=W")
 416         self.client("TX=10M", "RX=0", "qclose=Y", "sclose=Y")
 417         self.validate_ext_test_results()
 418
 419
 420 class QUICEchoExtEarlyScloseRxTestCase(QUICEchoExtTestCase):
 421     """QUIC Echo External Transfer Early Sclose Rx Test Case"""
 422
 423     @unittest.skipUnless(config.extended, "part of extended tests")
 424     @unittest.skip("testcase under development")
 425     def test_quic_ext_early_sclose_rx(self):
 426         """QUIC external transfer, early rx stream close"""
 427         self.server("TX=0", "RX=10M", "qclose=N", "sclose=Y")
 428         self.client("TX=20M", "RX=0", "qclose=W", "sclose=W", "tx-results-diff")
 429         self.validate_ext_test_results()
 430
 431
 432 class QUICEchoExtEarlyScloseTxTestCase(QUICEchoExtTestCase):
 433     """QUIC Echo External Transfer Early Sclose Tx Test Case"""
 434
 435     @unittest.skipUnless(config.extended, "part of extended tests")
 436     @unittest.skip("testcase under development")
 437     def test_quic_ext_early_sclose_tx(self):
 438         """QUIC external transfer, early tx stream close"""
 439         self.server("TX=0", "RX=20M", "qclose=W", "sclose=W", "rx-results-diff")
 440         self.client("TX=10M", "RX=0", "qclose=Y", "sclose=Y")
 441         self.validate_ext_test_results()
 442
 443
 444 class QUICEchoExtServerStreamTestCase(QUICEchoExtTestCase):
 445     """QUIC Echo External Transfer Server Stream Test Case"""
 446
 447     quic_setup = "serverstream"
 448     timeout = 60
 449
 450     def test_quic_ext_transfer_server_stream(self):
 451         """QUIC external server transfer"""
 452         self.server("TX=10M", "RX=0")
 453         self.client("TX=0", "RX=10M")
 454         self.validate_ext_test_results()
 455
 456
 457 class QUICEchoExtServerStreamBigTestCase(QUICEchoExtTestCase):
 458     """QUIC Echo External Transfer Server Stream Big Test Case"""
 459
 460     quic_setup = "serverstream"
 461     server_fifo_size = "4M"
 462     client_fifo_size = "4M"
 463     test_bytes = ""
 464     timeout = 60
 465
 466     @unittest.skipUnless(config.extended, "part of extended tests")
 467     def test_quic_ext_transfer_server_stream_big(self):
 468         """QUIC external server transfer, big stream"""
 469         self.server("TX=2G", "RX=0")
 470         self.client("TX=0", "RX=2G")
 471         self.validate_ext_test_results()
 472
 473
 474 class QUICEchoExtServerStreamQcloseRxTestCase(QUICEchoExtTestCase):
 475     """QUIC Echo External Transfer Server Stream Qclose Rx Test Case"""
 476
 477     quic_setup = "serverstream"
 478
 479     @unittest.skipUnless(config.extended, "part of extended tests")
 480     @unittest.skip("testcase under development")
 481     def test_quic_ext_server_stream_qclose_rx(self):
 482         """QUIC external server transfer, rx close"""
 483         self.server("TX=10M", "RX=0", "qclose=W", "sclose=W")
 484         self.client("TX=0", "RX=10M", "qclose=Y", "sclose=N")
 485         self.validate_ext_test_results()
 486
 487
 488 class QUICEchoExtServerStreamQcloseTxTestCase(QUICEchoExtTestCase):
 489     """QUIC Echo External Transfer Server Stream Qclose Tx Test Case"""
 490
 491     quic_setup = "serverstream"
 492
 493     @unittest.skipUnless(config.extended, "part of extended tests")
 494     @unittest.skip("testcase under development")
 495     def test_quic_ext_server_stream_qclose_tx(self):
 496         """QUIC external server transfer, tx close"""
 497         self.server("TX=10M", "RX=0", "qclose=Y", "sclose=N")
 498         self.client("TX=0", "RX=10M", "qclose=W", "sclose=W", "rx-results-diff")
 499         self.validate_ext_test_results()
 500
 501
 502 class QUICEchoExtServerStreamEarlyQcloseRxTestCase(QUICEchoExtTestCase):
 503     """QUIC Echo External Transfer Server Stream Early Qclose Rx Test Case"""
 504
 505     quic_setup = "serverstream"
 506
 507     @unittest.skipUnless(config.extended, "part of extended tests")
 508     @unittest.skip("testcase under development")
 509     def test_quic_ext_server_stream_early_qclose_rx(self):
 510         """QUIC external server transfer, early rx close"""
 511         self.server("TX=20M", "RX=0", "qclose=W", "sclose=W", "tx-results-diff")
 512         self.client("TX=0", "RX=10M", "qclose=Y", "sclose=N")
 513         self.validate_ext_test_results()
 514
 515
 516 class QUICEchoExtServerStreamEarlyQcloseTxTestCase(QUICEchoExtTestCase):
 517     """QUIC Echo External Transfer Server Stream Early Qclose Tx Test Case"""
 518
 519     quic_setup = "serverstream"
 520
 521     @unittest.skipUnless(config.extended, "part of extended tests")
 522     @unittest.skip("testcase under development")
 523     def test_quic_ext_server_stream_early_qclose_tx(self):
 524         """QUIC external server transfer, early tx close"""
 525         self.server("TX=10M", "RX=0", "qclose=Y", "sclose=N")
 526         self.client("TX=0", "RX=20M", "qclose=W", "sclose=W", "rx-results-diff")
 527         self.validate_ext_test_results()
 528
 529
 530 class QUICEchoExtServerStreamScloseRxTestCase(QUICEchoExtTestCase):
 531     """QUIC Echo External Transfer Server Stream Sclose Rx Test Case"""
 532
 533     quic_setup = "serverstream"
 534
 535     @unittest.skipUnless(config.extended, "part of extended tests")
 536     @unittest.skip("testcase under development")
 537     def test_quic_ext_server_stream_sclose_rx(self):
 538         """QUIC external server transfer, rx stream close"""
 539         self.server("TX=10M", "RX=0", "qclose=W", "sclose=W")
 540         self.client("TX=0", "RX=10M", "qclose=N", "sclose=Y")
 541         self.validate_ext_test_results()
 542
 543
 544 class QUICEchoExtServerStreamScloseTxTestCase(QUICEchoExtTestCase):
 545     """QUIC Echo External Transfer Server Stream Sclose Tx Test Case"""
 546
 547     quic_setup = "serverstream"
 548
 549     @unittest.skipUnless(config.extended, "part of extended tests")
 550     @unittest.skip("testcase under development")
 551     def test_quic_ext_server_stream_sclose_tx(self):
 552         """QUIC external server transfer, tx stream close"""
 553         self.server("TX=10M", "RX=0", "qclose=Y", "sclose=Y")
 554         self.client("TX=0", "RX=10M", "qclose=W", "sclose=W")
 555         self.validate_ext_test_results()
 556
 557
 558 class QUICEchoExtServerStreamEarlyScloseRxTestCase(QUICEchoExtTestCase):
 559     """QUIC Echo External Transfer Server Stream Early Sclose Rx Test Case"""
 560
 561     quic_setup = "serverstream"
 562
 563     @unittest.skipUnless(config.extended, "part of extended tests")
 564     @unittest.skip("testcase under development")
 565     def test_quic_ext_server_stream_early_sclose_rx(self):
 566         """QUIC external server transfer, early rx stream close"""
 567         self.server("TX=20M", "RX=0", "qclose=W", "sclose=W", "tx-results-diff")
 568         self.client("TX=0", "RX=10M", "qclose=N", "sclose=Y")
 569         self.validate_ext_test_results()
 570
 571
 572 class QUICEchoExtServerStreamEarlyScloseTxTestCase(QUICEchoExtTestCase):
 573     """QUIC Echo Ext Transfer Server Stream Early Sclose Tx Test Case"""
 574
 575     quic_setup = "serverstream"
 576
 577     @unittest.skipUnless(config.extended, "part of extended tests")
 578     @unittest.skip("testcase under development")
 579     def test_quic_ext_server_stream_early_sclose_tx(self):
 580         """QUIC external server transfer, early tx stream close"""
 581         self.server("TX=10M", "RX=0", "qclose=Y", "sclose=Y")
 582         self.client("TX=0", "RX=20M", "qclose=W", "sclose=W", "rx-results-diff")
 583         self.validate_ext_test_results()
 584
 585
 586 class QUICEchoExtServerStreamWorkersTestCase(QUICEchoExtTestCase):
 587     """QUIC Echo External Transfer Server Stream MultiWorker Test Case"""
 588
 589     quic_setup = "serverstream"
 590
 591     @unittest.skipUnless(config.extended, "part of extended tests")
 592     @unittest.skip("testcase under development")
 593     def test_quic_ext_transfer_server_stream_multi_workers(self):
 594         """QUIC external server transfer, multi-worker"""
 595         self.server("nclients", "4", "quic-streams", "4", "TX=10M", "RX=0")
 596         self.client("nclients", "4", "quic-streams", "4", "TX=0", "RX=10M")
 597         self.validate_ext_test_results()
 598
 599
 600 if __name__ == "__main__":
 601     unittest.main(testRunner=VppTestRunner)