def setup_wptrunner(venv, product, tests, wptrunner_args, prompt=True,):
    global logger

    wptparser = wptcommandline.create_parser()
    kwargs = utils.Kwargs(vars(wptparser.parse_args(wptrunner_args)).iteritems())

    wptrunner.setup_logging(kwargs, {"mach": sys.stdout})
    logger = wptrunner.logger

    kwargs["product"] = product
    kwargs["test_list"] = tests

    check_environ(product)
    args_general(kwargs)

    if product not in product_setup:
        exit("Unsupported product %s" % product)

    product_setup[product](venv, kwargs, prompt)

    wptcommandline.check_args(kwargs)

    wptrunner_path = os.path.join(wpt_root, "tools", "wptrunner")

    venv.install_requirements(os.path.join(wptrunner_path, "requirements.txt"))

    return kwargs

def run(config, args):
    logger = structuredlog.StructuredLogger("web-platform-tests")
    logger.add_handler(ResultHandler(logger=logger, verbose=args.verbose))
    setup_wptrunner_logging(logger)

    parser = wptcommandline.create_parser()

    logger.suite_start(tests=[])

    for product, product_settings in config["products"].iteritems():
        if args.product and product not in args.product:
            continue

        settings = test_settings()
        settings.update(config["general"])
        settings.update(product_settings)
        settings["product"] = product
        set_from_args(settings, args)

        kwargs = vars(parser.parse_args(settings_to_argv(settings)))
        wptcommandline.check_args(kwargs)

        logger.send_message("wptrunner-test", "set-product", product)

        run_tests(product, kwargs)

    logger.send_message("wptrunner-test", "set-product", None)
    logger.suite_end()

def create_parser_wpt():
    parser = wptcommandline.create_parser()
    parser.add_argument('--release', default=False, action="store_true",
                        help="Run with a release build of servo")
    parser.add_argument('--chaos', default=False, action="store_true",
                        help="Run under chaos mode in rr until a failure is captured")
    return parser

def main():
    parser = wptcommandline.create_parser()
    parser.add_argument('--update-manifest', dest='update_manifest', action='store_true')
    args = parser.parse_args()
    if args.update_manifest:
        return update_manifest()
    kwargs = set_defaults(args)
    return run_tests(**kwargs)

def create_parser_wpt():
    parser = wptcommandline.create_parser()
    parser.add_argument('--release', default=False, action="store_true",
                        help="Run with a release build of servo")
    parser.add_argument('--chaos', default=False, action="store_true",
                        help="Run under chaos mode in rr until a failure is captured")
    parser.add_argument('--pref', default=[], action="append", dest="prefs",
                        help="Pass preferences to servo")
    parser.add_argument('--always-succeed', default=False, action="store_true",
                        help="Always yield exit code of zero")
    return parser

def create_parser():
    from wptrunner import wptcommandline

    parser = argparse.ArgumentParser(add_help=False)
    parser.add_argument("product", action="store",
                        help="Browser to run tests in")
    parser.add_argument("--yes", "-y", dest="prompt", action="store_false", default=True,
                        help="Don't prompt before installing components")
    parser.add_argument("--stability", action="store_true",
                        help="Stability check tests")
    parser.add_argument("--install-browser", action="store_true",
                        help="Install the latest development version of the browser")
    parser._add_container_actions(wptcommandline.create_parser())
    return parser

def wptrunner_args(root, files_changed, iterations, browser):
    parser = wptcommandline.create_parser([browser.product])
    args = vars(parser.parse_args([]))
    wpt_root = os.path.join(root, "w3c", "web-platform-tests")
    args.update(browser.wptrunner_args(root))
    args.update({
        "tests_root": wpt_root,
        "metadata_root": wpt_root,
        "repeat": iterations,
        "config": "%s/w3c/wptrunner/wptrunner.default.ini" % root,
        "test_list": files_changed,
        "restart_on_unexpected": False,
        "pause_after_test": False
    })
    wptcommandline.check_args(args)
    return args

def wptrunner_args(root, files_changed, iterations, browser):
    """Derive and return arguments for wpt-runner."""
    parser = wptcommandline.create_parser([browser.product])
    args = vars(parser.parse_args([]))
    args.update(browser.wptrunner_args(root))
    args.update({
        "tests_root": wpt_root,
        "metadata_root": wpt_root,
        "repeat": iterations,
        "config": "%s//wptrunner.default.ini" % (wptrunner_root),
        "test_list": files_changed,
        "restart_on_unexpected": False,
        "pause_after_test": False
    })
    wptcommandline.check_args(args)
    return args

def create_parser():
    from wptrunner import wptcommandline

    parser = argparse.ArgumentParser(add_help=False)
    parser.add_argument("product", action="store",
                        help="Browser to run tests in")
    parser.add_argument("--yes", "-y", dest="prompt", action="store_false", default=True,
                        help="Don't prompt before installing components")
    parser.add_argument("--install-browser", action="store_true",
                        help="Install the browser")
    parser.add_argument("--channel", action="store",
                        choices=install.channel_by_name.keys(),
                        default=None, help='Name of browser release channel.'
                        '"stable" and "release" are synonyms for the latest browser stable release,'
                        '"nightly", "dev", "experimental", and "preview" are all synonyms for '
                        'the latest available development release. For WebDriver installs, '
                        'we attempt to select an appropriate, compatible, version for the '
                        'latest browser release on the selected channel.')
    parser._add_container_actions(wptcommandline.create_parser())
    return parser

def create_parser():
    from wptrunner import wptcommandline

    parser = argparse.ArgumentParser(add_help=False)
    parser.add_argument("product", action="store",
                        help="Browser to run tests in")
    parser.add_argument("--affected", action="store", default=None,
                        help="Run affected tests since revish")
    parser.add_argument("--yes", "-y", dest="prompt", action="store_false", default=True,
                        help="Don't prompt before installing components")
    parser.add_argument("--install-browser", action="store_true",
                        help="Install the browser from the release channel specified by --channel "
                        "(or the nightly channel by default).")
    parser.add_argument("--channel", action="store",
                        choices=install.channel_by_name.keys(),
                        default=None, help='Name of browser release channel. '
                        '"stable" and "release" are synonyms for the latest browser stable '
                        'release, "nightly", "dev", "experimental", and "preview" are all '
                        'synonyms for the latest available development release. (For WebDriver '
                        'installs, we attempt to select an appropriate, compatible version for '
                        'the latest browser release on the selected channel.) '
                        'This flag overrides --browser-channel.')
    parser._add_container_actions(wptcommandline.create_parser())
    return parser

def main():
    parser = wptcommandline.create_parser()
    args = parser.parse_args()
    kwargs = set_defaults(args)
    return run_tests(**kwargs)

def main():
    ensure_manifest()
    parser = wptcommandline.create_parser(False)
    args = parser.parse_args()
    kwargs = set_defaults(args)
    return run_tests(**kwargs)

 def __call__(self, parser, namespace, values, option_string=None):
     from wptrunner import wptcommandline
     wptparser = wptcommandline.create_parser()
     wptparser.usage = parser.usage
     wptparser.print_help()
     parser.exit()

def main(paths=None):
    parser = wptcommandline.create_parser()
    kwargs = vars(parser.parse_args())
    return run_tests(paths, **kwargs)

def create_parser_wpt():
    from wptrunner import wptcommandline
    return wptcommandline.create_parser(["firefox", "chrome", "edge", "servo"])

def main():
    parser = wptcommandline.create_parser()
    kwargs = vars(parser.parse_args())
    return update_tests(**kwargs)

def load_wpt_tests(xul_tester, requested_paths, excluded_paths):
    """Return a list of `RefTestCase` objects for the jsshell testharness.js
    tests filtered by the given paths and debug-ness."""
    repo_root = abspath(os.path.join(here, "..", "..", ".."))
    wp = os.path.join(repo_root, "testing", "web-platform")
    wpt = os.path.join(wp, "tests")

    sys_paths = [
        "python/mozterm",
        "python/mozboot",
        "testing/mozbase/mozcrash",
        "testing/mozbase/mozdevice",
        "testing/mozbase/mozfile",
        "testing/mozbase/mozinfo",
        "testing/mozbase/mozleak",
        "testing/mozbase/mozlog",
        "testing/mozbase/mozprocess",
        "testing/mozbase/mozprofile",
        "testing/mozbase/mozrunner",
        "testing/web-platform/",
        "testing/web-platform/tests/tools",
        "testing/web-platform/tests/tools/third_party/html5lib",
        "testing/web-platform/tests/tools/third_party/webencodings",
        "testing/web-platform/tests/tools/wptrunner",
        "testing/web-platform/tests/tools/wptserve",
        "third_party/python/requests",
    ]
    abs_sys_paths = [os.path.join(repo_root, path) for path in sys_paths]

    failed = False
    for path in abs_sys_paths:
        if not os.path.isdir(path):
            failed = True
            print("Could not add '%s' to the path")
    if failed:
        return []

    sys.path[0:0] = abs_sys_paths

    import manifestupdate
    from wptrunner import products, testloader, wptcommandline, wpttest, wptlogging

    manifest_root = tempfile.gettempdir()
    path_split = os.path.dirname(xul_tester.js_bin).split(os.path.sep)
    if path_split[-2:] == ["dist", "bin"]:
        maybe_root = os.path.join(*path_split[:-2])
        if os.path.exists(os.path.join(maybe_root, "_tests")):
            # Assume this is a gecko objdir.
            manifest_root = maybe_root

    logger = wptlogging.setup({}, {})

    manifestupdate.run(repo_root, manifest_root, logger)

    kwargs = vars(wptcommandline.create_parser().parse_args([]))
    kwargs.update({
        "config": os.path.join(manifest_root, "_tests", "web-platform", "wptrunner.local.ini"),
        "gecko_e10s": False,
        "verify": False,
        "wasm": xul_tester.test("wasmIsSupported()"),
    })
    wptcommandline.set_from_config(kwargs)
    test_paths = kwargs["test_paths"]

    def filter_jsshell_tests(it):
        for test in it:
            if test[1].get("jsshell"):
                yield test

    test_manifests = testloader.ManifestLoader(test_paths, types=["testharness"],
                                               meta_filters=[filter_jsshell_tests]).load()

    run_info_extras = products.load_product(kwargs["config"], "firefox")[-1](**kwargs)
    run_info = wpttest.get_run_info(kwargs["test_paths"]["/"]["metadata_path"],
                                    "firefox",
                                    debug=xul_tester.test("isDebugBuild"),
                                    extras=run_info_extras)

    path_filter = testloader.TestFilter(test_manifests,
                                        include=requested_paths,
                                        exclude=excluded_paths)
    loader = testloader.TestLoader(test_manifests,
                                   ["testharness"],
                                   run_info,
                                   manifest_filters=[path_filter])

    extra_helper_paths = [
        os.path.join(here, "web-platform-test-shims.js"),
        os.path.join(wpt, "resources", "testharness.js"),
        os.path.join(here, "testharnessreport.js"),
    ]

    def resolve(test_path, script):
        if script.startswith("/"):
            return os.path.join(wpt, script[1:])

        return os.path.join(wpt, os.path.dirname(test_path), script)

    return [
        RefTestCase(
#.........这里部分代码省略.........

def create_parser_wpt():
    from wptrunner import wptcommandline
    return wptcommandline.create_parser(["firefox"])

def create_parser_wpt():
    parser = wptcommandline.create_parser()
    parser.add_argument('--release', default=False, action="store_true",
                        help="Run with a release build of servo")
    return parser