diff --git a/python/servo/devenv_commands.py b/python/servo/devenv_commands.py
index 2619827c226b..0dc553fab00f 100644
--- a/python/servo/devenv_commands.py
+++ b/python/servo/devenv_commands.py
@@ -143,25 +143,28 @@ def grep(self, params):
             ["git"] + ["grep"] + params + ['--'] + grep_paths + [':(exclude)*.min.js'],
             env=self.build_env())
 
-    @Command('wpt-upgrade',
+    @Command('wptrunner-upgrade',
              description='upgrade wptrunner.',
              category='devenv')
     def upgrade_wpt_runner(self):
+        env = self.build_env()
         with cd(path.join(self.context.topdir, 'tests', 'wpt', 'harness')):
-            code = call(["git", "init"], env=self.build_env())
+            code = call(["git", "init"], env=env)
             if code:
                 return code
+            # No need to report an error if this fails, as it will for the first use
+            call(["git", "remote", "rm", "upstream"], env=env)
             code = call(
-                ["git", "remote", "add", "upstream", "https://github.com/w3c/wptrunner.git"], env=self.build_env())
+                ["git", "remote", "add", "upstream", "https://github.com/w3c/wptrunner.git"], env=env)
             if code:
                 return code
-            code = call(["git", "fetch", "upstream"], env=self.build_env())
+            code = call(["git", "fetch", "upstream"], env=env)
             if code:
                 return code
-            code = call(["git", "reset", "--hard", "remotes/upstream/master"], env=self.build_env())
+            code = call(["git", "reset", "--hard", "remotes/upstream/master"], env=env)
             if code:
                 return code
-            code = call(["rm", "-rf", ".git"], env=self.build_env())
+            code = call(["rm", "-rf", ".git"], env=env)
             if code:
                 return code
             return 0
diff --git a/tests/wpt/harness/.travis.yml b/tests/wpt/harness/.travis.yml
new file mode 100644
index 000000000000..b5ec736a3844
--- /dev/null
+++ b/tests/wpt/harness/.travis.yml
@@ -0,0 +1,26 @@
+language: python
+python: 2.7
+
+sudo: false
+
+cache:
+  directories:
+    - $HOME/.cache/pip
+
+env:
+  - TOXENV=py27-base
+  - TOXENV=py27-b2g
+  - TOXENV=py27-chrome
+  - TOXENV=py27-firefox
+  - TOXENV=py27-servo
+  - TOXENV=pypy-base
+  - TOXENV=pypy-b2g
+  - TOXENV=pypy-chrome
+  - TOXENV=pypy-firefox
+  - TOXENV=pypy-servo
+
+install:
+  - pip install -U tox
+
+script:
+  - tox
diff --git a/tests/wpt/harness/tox.ini b/tests/wpt/harness/tox.ini
new file mode 100644
index 000000000000..30a28e3cddb4
--- /dev/null
+++ b/tests/wpt/harness/tox.ini
@@ -0,0 +1,16 @@
+[pytest]
+xfail_strict=true
+
+[tox]
+envlist = {py27,pypy}-{base,b2g,chrome,firefox,servo}
+
+[testenv]
+deps =
+     pytest>=2.9
+     -r{toxinidir}/requirements.txt
+     b2g: -r{toxinidir}/requirements_b2g.txt
+     chrome: -r{toxinidir}/requirements_chrome.txt
+     firefox: -r{toxinidir}/requirements_firefox.txt
+     servo: -r{toxinidir}/requirements_servo.txt
+
+commands = py.test []
diff --git a/tests/wpt/harness/wptrunner/browsers/firefox.py b/tests/wpt/harness/wptrunner/browsers/firefox.py
index dcd7a4f1d17d..a3c6f3f5753f 100644
--- a/tests/wpt/harness/wptrunner/browsers/firefox.py
+++ b/tests/wpt/harness/wptrunner/browsers/firefox.py
@@ -3,6 +3,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 import os
+import platform
 import subprocess
 import sys
 
@@ -128,10 +129,16 @@ def start(self):
         self.profile.set_preferences({"marionette.defaultPrefs.enabled": True,
                                       "marionette.defaultPrefs.port": self.marionette_port,
                                       "dom.disable_open_during_load": False,
-                                      "network.dns.localDomains": ",".join(hostnames)})
+                                      "network.dns.localDomains": ",".join(hostnames),
+                                      "places.history.enabled": False})
         if self.e10s:
             self.profile.set_preferences({"browser.tabs.remote.autostart": True})
 
+        # Bug 1262954: winxp + e10s, disable hwaccel
+        if (self.e10s and platform.system() in ("Windows", "Microsoft") and
+            '5.1' in platform.version()):
+            self.profile.set_preferences({"layers.acceleration.disabled": True})
+
         if self.ca_certificate_path is not None:
             self.setup_ssl()
 
diff --git a/tests/wpt/harness/wptrunner/browsers/servo.py b/tests/wpt/harness/wptrunner/browsers/servo.py
index bc90cefcfc9e..4e4bc20128c4 100644
--- a/tests/wpt/harness/wptrunner/browsers/servo.py
+++ b/tests/wpt/harness/wptrunner/browsers/servo.py
@@ -6,7 +6,7 @@
 
 from .base import NullBrowser, ExecutorBrowser, require_arg
 from ..executors import executor_kwargs as base_executor_kwargs
-from ..executors.executorservo import ServoTestharnessExecutor, ServoRefTestExecutor
+from ..executors.executorservo import ServoTestharnessExecutor, ServoRefTestExecutor, ServoWdspecExecutor
 
 here = os.path.join(os.path.split(__file__)[0])
 
@@ -14,7 +14,8 @@
                  "check_args": "check_args",
                  "browser": "ServoBrowser",
                  "executor": {"testharness": "ServoTestharnessExecutor",
-                              "reftest": "ServoRefTestExecutor"},
+                              "reftest": "ServoRefTestExecutor",
+                              "wdspec": "ServoWdspecExecutor"},
                  "browser_kwargs": "browser_kwargs",
                  "executor_kwargs": "executor_kwargs",
                  "env_options": "env_options",
diff --git a/tests/wpt/harness/wptrunner/browsers/webdriver.py b/tests/wpt/harness/wptrunner/browsers/webdriver.py
deleted file mode 100644
index 54b1c1b5ef93..000000000000
--- a/tests/wpt/harness/wptrunner/browsers/webdriver.py
+++ /dev/null
@@ -1,137 +0,0 @@
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this file,
-# You can obtain one at http://mozilla.org/MPL/2.0/.
-
-import errno
-import socket
-import time
-import traceback
-import urlparse
-
-import mozprocess
-
-from .base import get_free_port, cmd_arg
-
-
-__all__ = ["SeleniumLocalServer", "ChromedriverLocalServer"]
-
-
-class LocalServer(object):
-    used_ports = set()
-    default_endpoint = "/"
-
-    def __init__(self, logger, binary, port=None, endpoint=None):
-        self.logger = logger
-        self.binary = binary
-        self.port = port
-        self.endpoint = endpoint or self.default_endpoint
-
-        if self.port is None:
-            self.port = get_free_port(4444, exclude=self.used_ports)
-        self.used_ports.add(self.port)
-        self.url = "http://127.0.0.1:%i%s" % (self.port, self.endpoint)
-
-        self.proc, self.cmd = None, None
-
-    def start(self):
-        self.proc = mozprocess.ProcessHandler(
-            self.cmd, processOutputLine=self.on_output)
-        try:
-            self.proc.run()
-        except OSError as e:
-            if e.errno == errno.ENOENT:
-                raise IOError(
-                    "chromedriver executable not found: %s" % self.binary)
-            raise
-
-        self.logger.debug(
-            "Waiting for server to become accessible: %s" % self.url)
-        surl = urlparse.urlparse(self.url)
-        addr = (surl.hostname, surl.port)
-        try:
-            wait_service(addr)
-        except:
-            self.logger.error(
-                "Server was not accessible within the timeout:\n%s" % traceback.format_exc())
-            raise
-        else:
-            self.logger.info("Server listening on port %i" % self.port)
-
-    def stop(self):
-        if hasattr(self.proc, "proc"):
-            self.proc.kill()
-
-    def is_alive(self):
-        if hasattr(self.proc, "proc"):
-            exitcode = self.proc.poll()
-            return exitcode is None
-        return False
-
-    def on_output(self, line):
-        self.logger.process_output(self.pid,
-                                   line.decode("utf8", "replace"),
-                                   command=" ".join(self.cmd))
-
-    @property
-    def pid(self):
-        if hasattr(self.proc, "proc"):
-            return self.proc.pid
-
-
-class SeleniumLocalServer(LocalServer):
-    default_endpoint = "/wd/hub"
-
-    def __init__(self, logger, binary, port=None):
-        LocalServer.__init__(self, logger, binary, port=port)
-        self.cmd = ["java",
-                    "-jar", self.binary,
-                    "-port", str(self.port)]
-
-    def start(self):
-        self.logger.debug("Starting local Selenium server")
-        LocalServer.start(self)
-
-    def stop(self):
-        LocalServer.stop(self)
-        self.logger.info("Selenium server stopped listening")
-
-
-class ChromedriverLocalServer(LocalServer):
-    default_endpoint = "/wd/hub"
-
-    def __init__(self, logger, binary="chromedriver", port=None, endpoint=None):
-        LocalServer.__init__(self, logger, binary, port=port, endpoint=endpoint)
-        # TODO: verbose logging
-        self.cmd = [self.binary,
-                    cmd_arg("port", str(self.port)) if self.port else "",
-                    cmd_arg("url-base", self.endpoint) if self.endpoint else ""]
-
-    def start(self):
-        self.logger.debug("Starting local chromedriver server")
-        LocalServer.start(self)
-
-    def stop(self):
-        LocalServer.stop(self)
-        self.logger.info("chromedriver server stopped listening")
-
-
-def wait_service(addr, timeout=15):
-    """Waits until network service given as a tuple of (host, port) becomes
-    available or the `timeout` duration is reached, at which point
-    ``socket.error`` is raised."""
-    end = time.time() + timeout
-    while end > time.time():
-        so = socket.socket()
-        try:
-            so.connect(addr)
-        except socket.timeout:
-            pass
-        except socket.error as e:
-            if e[0] != errno.ECONNREFUSED:
-                raise
-        else:
-            return True
-        finally:
-            so.close()
-        time.sleep(0.5)
-    raise socket.error("Service is unavailable: %s:%i" % addr)
diff --git a/tests/wpt/harness/wptrunner/executors/executormarionette.py b/tests/wpt/harness/wptrunner/executors/executormarionette.py
index c4b1cba689af..50200d74677f 100644
--- a/tests/wpt/harness/wptrunner/executors/executormarionette.py
+++ b/tests/wpt/harness/wptrunner/executors/executormarionette.py
@@ -292,7 +292,7 @@ def is_alive(self):
 class ExecuteAsyncScriptRun(object):
     def __init__(self, logger, func, marionette, url, timeout):
         self.logger = logger
-        self.result = None
+        self.result = (None, None)
         self.marionette = marionette
         self.func = func
         self.url = url
@@ -323,11 +323,9 @@ def run(self):
             wait_timeout = None
 
         flag = self.result_flag.wait(wait_timeout)
-        if self.result is None:
+        if self.result[1] is None:
             self.logger.debug("Timed out waiting for a result")
-            assert not flag
             self.result = False, ("EXTERNAL-TIMEOUT", None)
-
         return self.result
 
     def _run(self):
@@ -409,7 +407,8 @@ def do_testharness(self, marionette, url, timeout):
                                 "timeout": timeout_ms,
                                 "explicit_timeout": timeout is None}
 
-        return marionette.execute_async_script(script, new_sandbox=False)
+        rv = marionette.execute_async_script(script, new_sandbox=False)
+        return rv
 
 
 class MarionetteRefTestExecutor(RefTestExecutor):
@@ -487,7 +486,7 @@ def _screenshot(self, marionette, url, timeout):
 class WdspecRun(object):
     def __init__(self, func, session, path, timeout):
         self.func = func
-        self.result = None
+        self.result = (None, None)
         self.session = session
         self.path = path
         self.timeout = timeout
@@ -504,8 +503,7 @@ def run(self):
         executor.start()
 
         flag = self.result_flag.wait(self.timeout)
-        if self.result is None:
-            assert not flag
+        if self.result[1] is None:
             self.result = False, ("EXTERNAL-TIMEOUT", None)
 
         return self.result
diff --git a/tests/wpt/harness/wptrunner/executors/executorservo.py b/tests/wpt/harness/wptrunner/executors/executorservo.py
index 7f5e90673197..2d9c8c1e865f 100644
--- a/tests/wpt/harness/wptrunner/executors/executorservo.py
+++ b/tests/wpt/harness/wptrunner/executors/executorservo.py
@@ -4,11 +4,13 @@
 
 import base64
 import hashlib
+import httplib
 import json
 import os
 import subprocess
 import tempfile
 import threading
+import traceback
 import urlparse
 import uuid
 from collections import defaultdict
@@ -19,15 +21,23 @@
                    Protocol,
                    RefTestImplementation,
                    testharness_result_converter,
-                   reftest_result_converter)
+                   reftest_result_converter,
+                   WdspecExecutor)
 from .process import ProcessTestExecutor
 from ..browsers.base import browser_command
-render_arg = None
+from ..wpttest import WdspecResult, WdspecSubtestResult
+from ..webdriver_server import ServoDriverServer
+from .executormarionette import WdspecRun
+from . import pytestrunner
 
+render_arg = None
+webdriver = None
+extra_timeout = 5 # seconds
 
 def do_delayed_imports():
-    global render_arg
+    global render_arg, webdriver
     from ..browsers.servo import render_arg
+    import webdriver
 
 hosts_text = """127.0.0.1 web-platform.test
 127.0.0.1 www.web-platform.test
@@ -214,10 +224,7 @@ def screenshot(self, test, viewport_size, dpi):
             for pref in test.environment.get('prefs', {}):
                 command += ["--pref", pref]
 
-            if viewport_size:
-                command += ["--resolution", viewport_size]
-            else:
-                command += ["--resolution", "800x600"]
+            command += ["--resolution", viewport_size or "800x600"]
 
             if dpi:
                 command += ["--device-pixel-ratio", dpi]
@@ -275,3 +282,77 @@ def on_output(self, line):
             self.logger.process_output(self.proc.pid,
                                        line,
                                        " ".join(self.command))
+
+class ServoWdspecProtocol(Protocol):
+    def __init__(self, executor, browser):
+        do_delayed_imports()
+        Protocol.__init__(self, executor, browser)
+        self.session = None
+        self.server = None
+
+    def setup(self, runner):
+        try:
+            self.server = ServoDriverServer(self.logger, binary=self.browser.binary, binary_args=self.browser.binary_args, render_backend=self.browser.render_backend)
+            self.server.start(block=False)
+            self.logger.info(
+                "WebDriver HTTP server listening at %s" % self.server.url)
+
+            self.logger.info(
+                "Establishing new WebDriver session with %s" % self.server.url)
+            self.session = webdriver.Session(
+                self.server.host, self.server.port, self.server.base_path)
+        except Exception:
+            self.logger.error(traceback.format_exc())
+            self.executor.runner.send_message("init_failed")
+        else:
+            self.executor.runner.send_message("init_succeeded")
+
+    def teardown(self):
+        if self.server is not None:
+            try:
+                if self.session.session_id is not None:
+                    self.session.end()
+            except Exception:
+                pass
+            if self.server.is_alive:
+                self.server.stop()
+
+    @property
+    def is_alive(self):
+        conn = httplib.HTTPConnection(self.server.host, self.server.port)
+        conn.request("HEAD", self.server.base_path + "invalid")
+        res = conn.getresponse()
+        return res.status == 404
+
+class ServoWdspecExecutor(WdspecExecutor):
+    def __init__(self, browser, server_config,
+                 timeout_multiplier=1, close_after_done=True, debug_info=None,
+                 **kwargs):
+        WdspecExecutor.__init__(self, browser, server_config,
+                                timeout_multiplier=timeout_multiplier,
+                                debug_info=debug_info)
+        self.protocol = ServoWdspecProtocol(self, browser)
+
+    def is_alive(self):
+        return self.protocol.is_alive
+
+    def on_environment_change(self, new_environment):
+        pass
+
+    def do_test(self, test):
+        timeout = test.timeout * self.timeout_multiplier + extra_timeout
+
+        success, data = WdspecRun(self.do_wdspec,
+                                  self.protocol.session,
+                                  test.path,
+                                  timeout).run()
+
+        if success:
+            return self.convert_result(test, data)
+
+        return (test.result_cls(*data), [])
+
+    def do_wdspec(self, session, path, timeout):
+        harness_result = ("OK", None)
+        subtest_results = pytestrunner.run(path, session, timeout=timeout)
+        return (harness_result, subtest_results)
diff --git a/tests/wpt/harness/wptrunner/executors/pytestrunner/fixtures.py b/tests/wpt/harness/wptrunner/executors/pytestrunner/fixtures.py
index 77afb4a36842..b2b9913bf487 100644
--- a/tests/wpt/harness/wptrunner/executors/pytestrunner/fixtures.py
+++ b/tests/wpt/harness/wptrunner/executors/pytestrunner/fixtures.py
@@ -2,8 +2,12 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this file,
 # You can obtain one at http://mozilla.org/MPL/2.0/.
 
-import pytest
+from tools import pytest
 
+@pytest.fixture
+def webdriver():
+    import webdriver
+    return webdriver
 
 """pytest fixtures for use in Python-based WPT tests.
 
@@ -17,7 +21,7 @@ class Session(object):
     in tests.
 
     The session is not created by default to enable testing of session
-    creation.  However, a module-scoped session will be implicitly created
+    creation.  However, a function-scoped session will be implicitly created
     at the first call to a WebDriver command.  This means methods such as
     `session.send_command` and `session.session_id` are possible to use
     without having a session.
@@ -45,14 +49,62 @@ def setup(request, session):
         def test_something(setup, session):
             assert session.url == "https://example.org"
 
-    The session is closed when the test module goes out of scope by an
-    implicit call to `session.end`.
+    When the test function goes out of scope, any remaining user prompts
+    and opened windows are closed, and the current browsing context is
+    switched back to the top-level browsing context.
     """
 
     def __init__(self, client):
         self.client = client
 
-    @pytest.fixture(scope="module")
+    @pytest.fixture(scope="function")
     def session(self, request):
-        request.addfinalizer(self.client.end)
+        # finalisers are popped off a stack,
+        # making their ordering reverse
+        request.addfinalizer(self.switch_to_top_level_browsing_context)
+        request.addfinalizer(self.restore_windows)
+        request.addfinalizer(self.dismiss_user_prompts)
+
         return self.client
+
+    def dismiss_user_prompts(self):
+        """Dismisses any open user prompts in windows."""
+        current_window = self.client.window_handle
+
+        for window in self.windows():
+            self.client.window_handle = window
+            try:
+                self.client.alert.dismiss()
+            except webdriver.NoSuchAlertException:
+                pass
+
+        self.client.window_handle = current_window
+
+    def restore_windows(self):
+        """Closes superfluous windows opened by the test without ending
+        the session implicitly by closing the last window.
+        """
+        current_window = self.client.window_handle
+
+        for window in self.windows(exclude=[current_window]):
+            self.client.window_handle = window
+            if len(self.client.window_handles) > 1:
+                self.client.close()
+
+        self.client.window_handle = current_window
+
+    def switch_to_top_level_browsing_context(self):
+        """If the current browsing context selected by WebDriver is a
+        `<frame>` or an `<iframe>`, switch it back to the top-level
+        browsing context.
+        """
+        self.client.switch_frame(None)
+
+    def windows(self, exclude=None):
+        """Set of window handles, filtered by an `exclude` list if
+        provided.
+        """
+        if exclude is None:
+            exclude = []
+        wins = [w for w in self.client.window_handles if w not in exclude]
+        return set(wins)
diff --git a/tests/wpt/harness/wptrunner/executors/webdriver.py b/tests/wpt/harness/wptrunner/executors/webdriver.py
deleted file mode 100644
index dee2a1c23378..000000000000
--- a/tests/wpt/harness/wptrunner/executors/webdriver.py
+++ /dev/null
@@ -1,642 +0,0 @@
-import errno
-import httplib
-import json
-import socket
-import time
-import urlparse
-from collections import defaultdict
-
-element_key = "element-6066-11e4-a52e-4f735466cecf"
-
-
-class WebDriverException(Exception):
-    http_status = None
-    status_code = None
-
-    def __init__(self, message):
-        self.message = message
-
-
-class ElementNotSelectableException(WebDriverException):
-    http_status = 400
-    status_code = "element not selectable"
-
-
-class ElementNotVisibleException(WebDriverException):
-    http_status = 400
-    status_code = "element not visible"
-
-
-class InvalidArgumentException(WebDriverException):
-    http_status = 400
-    status_code = "invalid argument"
-
-
-class InvalidCookieDomainException(WebDriverException):
-    http_status = 400
-    status_code = "invalid cookie domain"
-
-
-class InvalidElementCoordinatesException(WebDriverException):
-    http_status = 400
-    status_code = "invalid element coordinates"
-
-
-class InvalidElementStateException(WebDriverException):
-    http_status = 400
-    status_code = "invalid cookie domain"
-
-
-class InvalidSelectorException(WebDriverException):
-    http_status = 400
-    status_code = "invalid selector"
-
-
-class InvalidSessionIdException(WebDriverException):
-    http_status = 404
-    status_code = "invalid session id"
-
-
-class JavascriptErrorException(WebDriverException):
-    http_status = 500
-    status_code = "javascript error"
-
-
-class MoveTargetOutOfBoundsException(WebDriverException):
-    http_status = 500
-    status_code = "move target out of bounds"
-
-
-class NoSuchAlertException(WebDriverException):
-    http_status = 400
-    status_code = "no such alert"
-
-
-class NoSuchElementException(WebDriverException):
-    http_status = 404
-    status_code = "no such element"
-
-
-class NoSuchFrameException(WebDriverException):
-    http_status = 400
-    status_code = "no such frame"
-
-
-class NoSuchWindowException(WebDriverException):
-    http_status = 400
-    status_code = "no such window"
-
-
-class ScriptTimeoutException(WebDriverException):
-    http_status = 408
-    status_code = "script timeout"
-
-
-class SessionNotCreatedException(WebDriverException):
-    http_status = 500
-    status_code = "session not created"
-
-
-class StaleElementReferenceException(WebDriverException):
-    http_status = 400
-    status_code = "stale element reference"
-
-
-class TimeoutException(WebDriverException):
-    http_status = 408
-    status_code = "timeout"
-
-
-class UnableToSetCookieException(WebDriverException):
-    http_status = 500
-    status_code = "unable to set cookie"
-
-
-class UnexpectedAlertOpenException(WebDriverException):
-    http_status = 500
-    status_code = "unexpected alert open"
-
-
-class UnknownErrorException(WebDriverException):
-    http_status = 500
-    status_code = "unknown error"
-
-
-class UnknownCommandException(WebDriverException):
-    http_status = (404, 405)
-    status_code = "unknown command"
-
-
-class UnsupportedOperationException(WebDriverException):
-    http_status = 500
-    status_code = "unsupported operation"
-
-
-def group_exceptions():
-    exceptions = defaultdict(dict)
-    for item in _objs:
-        if type(item) == type and issubclass(item, WebDriverException):
-            if not isinstance(item.http_status, tuple):
-                statuses = (item.http_status,)
-            else:
-                statuses = item.http_status
-
-            for status in statuses:
-                exceptions[status][item.status_code] = item
-    return exceptions
-
-
-_objs = locals().values()
-_exceptions = group_exceptions()
-del _objs
-del group_exceptions
-
-
-def wait_for_port(host, port, timeout=60):
-    """ Wait for the specified Marionette host/port to be available."""
-    starttime = time.time()
-    poll_interval = 0.1
-    while time.time() - starttime < timeout:
-        sock = None
-        try:
-            sock = socket.socket()
-            sock.connect((host, port))
-            return True
-        except socket.error as e:
-            if e[0] != errno.ECONNREFUSED:
-                raise
-        finally:
-            if sock:
-                sock.close()
-        time.sleep(poll_interval)
-    return False
-
-
-class Transport(object):
-    def __init__(self, host, port, url_prefix="", port_timeout=60):
-        self.host = host
-        self.port = port
-        self.port_timeout = port_timeout
-        if url_prefix == "":
-            self.path_prefix = "/"
-        else:
-            self.path_prefix = "/%s/" % url_prefix.strip("/")
-        self._connection = None
-
-    def connect(self):
-        wait_for_port(self.host, self.port, self.port_timeout)
-        self._connection = httplib.HTTPConnection(self.host, self.port)
-
-    def close_connection(self):
-        if self._connection:
-            self._connection.close()
-        self._connection = None
-
-    def url(self, suffix):
-        return urlparse.urljoin(self.url_prefix, suffix)
-
-    def send(self, method, url, body=None, headers=None, key=None):
-        if not self._connection:
-            self.connect()
-
-        if body is None and method == "POST":
-            body = {}
-
-        if isinstance(body, dict):
-            body = json.dumps(body)
-
-        if isinstance(body, unicode):
-            body = body.encode("utf-8")
-
-        if headers is None:
-            headers = {}
-
-        url = self.path_prefix + url
-
-        self._connection.request(method, url, body, headers)
-
-        try:
-            resp = self._connection.getresponse()
-        except Exception:
-            # This should probably be more specific
-            raise IOError
-        resp_body = resp.read()
-
-        try:
-            data = json.loads(resp_body)
-        except:
-            raise WebDriverException("Could not parse response body as JSON: %s" % body)
-
-        if resp.status != 200:
-            cls = _exceptions.get(resp.status, {}).get(data.get("status", None), WebDriverException)
-            raise cls(data.get("message", ""))
-
-        if key is not None:
-            data = data[key]
-
-        if not data:
-            data = None
-
-        return data
-
-
-def command(func):
-    def inner(self, *args, **kwargs):
-        if hasattr(self, "session"):
-            session_id = self.session.session_id
-        else:
-            session_id = self.session_id
-
-        if session_id is None:
-            raise SessionNotCreatedException("Session not created")
-        return func(self, *args, **kwargs)
-
-    inner.__name__ = func.__name__
-    inner.__doc__ = func.__doc__
-
-    return inner
-
-
-class Timeouts(object):
-    def __init__(self, session):
-        self.session = session
-        self._script = 30
-        self._load = 0
-        self._implicit_wait = 0
-
-    def _set_timeouts(self, name, value):
-        body = {"type": name,
-                "ms": value * 1000}
-        return self.session.send_command("POST", "timeouts", body)
-
-    @property
-    def script(self):
-        return self._script
-
-    @script.setter
-    def script(self, value):
-        self._set_timeouts("script", value)
-        self._script = value
-
-    @property
-    def load(self):
-        return self._load
-
-    @load.setter
-    def set_load(self, value):
-        self._set_timeouts("page load", value)
-        self._script = value
-
-    @property
-    def implicit_wait(self):
-        return self._implicit_wait
-
-    @implicit_wait.setter
-    def implicit_wait(self, value):
-        self._set_timeouts("implicit wait", value)
-        self._implicit_wait = value
-
-
-class Window(object):
-    def __init__(self, session):
-        self.session = session
-
-    @property
-    @command
-    def size(self):
-        return self.session.send_command("GET", "window/size")
-
-    @size.setter
-    @command
-    def size(self, (height, width)):
-        body = {"width": width,
-                "height": height}
-
-        return self.session.send_command("POST", "window/size", body)
-
-    @property
-    @command
-    def maximize(self):
-        return self.session.send_command("POST", "window/maximize")
-
-
-class Find(object):
-    def __init__(self, session):
-        self.session = session
-
-    @command
-    def css(self, selector, all=True):
-        return self._find_element("css selector", selector, all)
-
-    def _find_element(self, strategy, selector, all):
-        route = "elements" if all else "element"
-
-        body = {"using": strategy,
-                "value": selector}
-
-        data = self.session.send_command("POST", route, body, key="value")
-
-        if all:
-            rv = [self.session._element(item) for item in data]
-        else:
-            rv = self.session._element(data)
-
-        return rv
-
-
-class Cookies(object):
-    def __init__(self, session):
-        self.session = session
-
-    def __getitem__(self, name):
-        self.session.send_command("GET", "cookie/%s" % name, {}, key="value")
-
-    def __setitem__(self, name, value):
-        cookie = {"name": name,
-                  "value": None}
-
-        if isinstance(name, (str, unicode)):
-            cookie["value"] = value
-        elif hasattr(value, "value"):
-            cookie["value"] = value.value
-        self.session.send_command("POST", "cookie/%s" % name, {}, key="value")
-
-
-class Session(object):
-    def __init__(self, host, port, url_prefix="", desired_capabilities=None, port_timeout=60,
-                 extension=None):
-        self.transport = Transport(host, port, url_prefix, port_timeout)
-        self.desired_capabilities = desired_capabilities
-        self.session_id = None
-        self.timeouts = None
-        self.window = None
-        self.find = None
-        self._element_cache = {}
-        self.extension = None
-        self.extension_cls = extension
-
-    def start(self):
-        desired_capabilities = self.desired_capabilities if self.desired_capabilities else {}
-        body = {"capabilities": {"desiredCapabilites": desired_capabilities}}
-
-        rv = self.transport.send("POST", "session", body=body)
-        self.session_id = rv["sessionId"]
-
-        self.timeouts = Timeouts(self)
-        self.window = Window(self)
-        self.find = Find(self)
-        if self.extension_cls:
-            self.extension = self.extension_cls(self)
-
-        return rv["value"]
-
-    @command
-    def end(self):
-        url = "session/%s" % self.session_id
-        self.transport.send("DELETE", url)
-        self.session_id = None
-        self.timeouts = None
-        self.window = None
-        self.find = None
-        self.extension = None
-        self.transport.close_connection()
-
-    def __enter__(self):
-        resp = self.start()
-        if resp.error:
-            raise Exception(resp)
-        return self
-
-    def __exit__(self, *args, **kwargs):
-        resp = self.end()
-        if resp.error:
-            raise Exception(resp)
-
-    def send_command(self, method, url, body=None, key=None):
-        url = urlparse.urljoin("session/%s/" % self.session_id, url)
-        return self.transport.send(method, url, body, key=key)
-
-    @property
-    @command
-    def url(self):
-        return self.send_command("GET", "url", key="value")
-
-    @url.setter
-    @command
-    def url(self, url):
-        if urlparse.urlsplit(url).netloc is None:
-            return self.url(url)
-        body = {"url": url}
-        return self.send_command("POST", "url", body)
-
-    @command
-    def back(self):
-        return self.send_command("POST", "back")
-
-    @command
-    def forward(self):
-        return self.send_command("POST", "forward")
-
-    @command
-    def refresh(self):
-        return self.send_command("POST", "refresh")
-
-    @property
-    @command
-    def title(self):
-        return self.send_command("GET", "title", key="value")
-
-    @property
-    @command
-    def handle(self):
-        return self.send_command("GET", "window_handle", key="value")
-
-    @handle.setter
-    @command
-    def handle(self, handle):
-        body = {"handle": handle}
-        return self.send_command("POST", "window", body=body)
-
-    def switch_frame(self, frame):
-        if frame == "parent":
-            url = "frame/parent"
-            body = None
-        else:
-            url = "frame"
-            if isinstance(frame, Element):
-                body = {"id": frame.json()}
-            else:
-                body = {"id": frame}
-
-        return self.send_command("POST", url, body)
-
-    @command
-    def close(self):
-        return self.send_command("DELETE", "window_handle")
-
-    @property
-    @command
-    def handles(self):
-        return self.send_command("GET", "window_handles", key="value")
-
-    @property
-    @command
-    def active_element(self):
-        data = self.send_command("GET", "element/active", key="value")
-        if data is not None:
-            return self._element(data)
-
-    def _element(self, data):
-        elem_id = data[element_key]
-        assert elem_id
-        if elem_id in self._element_cache:
-            return self._element_cache[elem_id]
-        return Element(self, elem_id)
-
-    @command
-    def cookies(self, name=None):
-        if name is None:
-            url = "cookie"
-        else:
-            url = "cookie/%s" % name
-        return self.send_command("GET", url, {}, key="value")
-
-    @command
-    def set_cookie(self, name, value, path=None, domain=None, secure=None, expiry=None):
-        body = {"name": name,
-                "value": value}
-        if path is not None:
-            body["path"] = path
-        if domain is not None:
-            body["domain"] = domain
-        if secure is not None:
-            body["secure"] = secure
-        if expiry is not None:
-            body["expiry"] = expiry
-        self.send_command("POST", "cookie", {"cookie": body})
-
-    def delete_cookie(self, name=None):
-        if name is None:
-            url = "cookie"
-        else:
-            url = "cookie/%s" % name
-        self.send_command("DELETE", url, {}, key="value")
-
-    #[...]
-
-    @command
-    def execute_script(self, script, args=None):
-        if args is None:
-            args = []
-
-        body = {
-            "script": script,
-            "args": args
-        }
-        return self.send_command("POST", "execute", body, key="value")
-
-    @command
-    def execute_async_script(self, script, args=None):
-        if args is None:
-            args = []
-
-        body = {
-            "script": script,
-            "args": args
-        }
-        return self.send_command("POST", "execute_async", body, key="value")
-
-    #[...]
-
-    @command
-    def screenshot(self):
-        return self.send_command("GET", "screenshot", key="value")
-
-
-class Element(object):
-    def __init__(self, session, id):
-        self.session = session
-        self.id = id
-        assert id not in self.session._element_cache
-        self.session._element_cache[self.id] = self
-
-    def json(self):
-        return {element_key: self.id}
-
-    @property
-    def session_id(self):
-        return self.session.session_id
-
-    def url(self, suffix):
-        return "element/%s/%s" % (self.id, suffix)
-
-    @command
-    def find_element(self, strategy, selector):
-        body = {"using": strategy,
-                "value": selector}
-
-        elem = self.session.send_command("POST", self.url("element"), body, key="value")
-        return self.session.element(elem)
-
-    @command
-    def click(self):
-        self.session.send_command("POST", self.url("click"), {})
-
-    @command
-    def tap(self):
-        self.session.send_command("POST", self.url("tap"), {})
-
-    @command
-    def clear(self):
-        self.session.send_command("POST", self.url("clear"), {})
-
-    @command
-    def send_keys(self, keys):
-        if isinstance(keys, (str, unicode)):
-            keys = [char for char in keys]
-
-        body = {"value": keys}
-
-        return self.session.send_command("POST", self.url("value"), body)
-
-    @property
-    @command
-    def text(self):
-        return self.session.send_command("GET", self.url("text"))
-
-    @property
-    @command
-    def name(self):
-        return self.session.send_command("GET", self.url("name"))
-
-    @command
-    def style(self, property_name):
-        return self.session.send_command("GET", self.url("css/%s" % property_name))
-
-    @property
-    @command
-    def rect(self):
-        return self.session.send_command("GET", self.url("rect"))
-
-    @command
-    def attribute(self, name):
-        return self.session.send_command("GET", self.url("attribute/%s" % name))
-
-class ServoExtensions(object):
-    def __init__(self, session):
-        self.session = session
-
-    @command
-    def get_prefs(self, *prefs):
-        body = {"prefs": list(prefs)}
-        return self.session.send_command("POST", "servo/prefs/get", body)
-
-    @command
-    def set_prefs(self, prefs):
-        body = {"prefs": prefs}
-        return self.session.send_command("POST", "servo/prefs/set", body)
-
-    @command
-    def reset_prefs(self, *prefs):
-        body = {"prefs": list(prefs)}
-        return self.session.send_command("POST", "servo/prefs/reset", body)
diff --git a/tests/wpt/harness/wptrunner/testharnessreport-servo.js b/tests/wpt/harness/wptrunner/testharnessreport-servo.js
index d1b316761709..1a8ef2d1465c 100644
--- a/tests/wpt/harness/wptrunner/testharnessreport-servo.js
+++ b/tests/wpt/harness/wptrunner/testharnessreport-servo.js
@@ -8,7 +8,7 @@ setup(props);
 
 add_completion_callback(function (tests, harness_status) {
     var id = location.pathname + location.search + location.hash;
-    alert("RESULT: " + JSON.stringify([
+    console.log("ALERT RESULT: " + JSON.stringify([
         id,
         harness_status.status,
         harness_status.message,
diff --git a/tests/wpt/harness/wptrunner/tests/test_chunker.py b/tests/wpt/harness/wptrunner/tests/test_chunker.py
index d46ad2587838..84af2dc67ef6 100644
--- a/tests/wpt/harness/wptrunner/tests/test_chunker.py
+++ b/tests/wpt/harness/wptrunner/tests/test_chunker.py
@@ -4,7 +4,11 @@
 
 import unittest
 import sys
-sys.path.insert(0, "..")
+from os.path import join, dirname
+
+import pytest
+
+sys.path.insert(0, join(dirname(__file__), "..", ".."))
 
 from wptrunner import wptrunner
 
@@ -25,6 +29,7 @@ def make_mock_manifest(*items):
 
 class TestEqualTimeChunker(unittest.TestCase):
 
+    @pytest.mark.xfail
     def test_include_all(self):
         tests = make_mock_manifest(("a", 10), ("a/b", 10), ("c", 10))
 
@@ -36,6 +41,7 @@ def test_include_all(self):
         self.assertEquals(tests[10:20], chunk_2)
         self.assertEquals(tests[20:], chunk_3)
 
+    @pytest.mark.xfail
     def test_include_all_1(self):
         tests = make_mock_manifest(("a", 5), ("a/b", 5), ("c", 10), ("d", 10))
 
@@ -47,6 +53,7 @@ def test_include_all_1(self):
         self.assertEquals(tests[10:20], chunk_2)
         self.assertEquals(tests[20:], chunk_3)
 
+    @pytest.mark.xfail
     def test_long(self):
         tests = make_mock_manifest(("a", 100), ("a/b", 1), ("c", 1))
 
@@ -58,6 +65,7 @@ def test_long(self):
         self.assertEquals(tests[100:101], chunk_2)
         self.assertEquals(tests[101:102], chunk_3)
 
+    @pytest.mark.xfail
     def test_long_1(self):
         tests = make_mock_manifest(("a", 1), ("a/b", 100), ("c", 1))
 
@@ -69,6 +77,7 @@ def test_long_1(self):
         self.assertEquals(tests[1:101], chunk_2)
         self.assertEquals(tests[101:102], chunk_3)
 
+    @pytest.mark.xfail
     def test_too_few_dirs(self):
         with self.assertRaises(ValueError):
             tests = make_mock_manifest(("a", 1), ("a/b", 100), ("c", 1))
diff --git a/tests/wpt/harness/wptrunner/tests/test_hosts.py b/tests/wpt/harness/wptrunner/tests/test_hosts.py
index 4f122640d58a..3f9006273df8 100644
--- a/tests/wpt/harness/wptrunner/tests/test_hosts.py
+++ b/tests/wpt/harness/wptrunner/tests/test_hosts.py
@@ -4,11 +4,12 @@
 
 import unittest
 import sys
+from os.path import join, dirname
 from cStringIO import StringIO
 
-sys.path.insert(0, "..")
+sys.path.insert(0, join(dirname(__file__), "..", ".."))
 
-import hosts
+from wptrunner import hosts
 
 
 class HostsTest(unittest.TestCase):
diff --git a/tests/wpt/harness/wptrunner/tests/test_update.py b/tests/wpt/harness/wptrunner/tests/test_update.py
index 2d77b326d615..50878ac56dc0 100644
--- a/tests/wpt/harness/wptrunner/tests/test_update.py
+++ b/tests/wpt/harness/wptrunner/tests/test_update.py
@@ -5,6 +5,8 @@
 import unittest
 import StringIO
 
+import pytest
+
 from .. import metadata, manifestupdate
 from mozlog import structuredlog, handlers, formatters
 
@@ -51,6 +53,7 @@ def coalesce_results(self, trees):
                     subtest.coalesce_expected()
                 test.coalesce_expected()
 
+    @pytest.mark.xfail
     def test_update_0(self):
         prev_data = [("path/to/test.htm.ini", ["/path/to/test.htm"], """[test.htm]
   type: testharness
@@ -71,6 +74,7 @@ def test_update_0(self):
         self.coalesce_results([new_manifest])
         self.assertTrue(new_manifest.is_empty)
 
+    @pytest.mark.xfail
     def test_update_1(self):
         test_id = "/path/to/test.htm"
         prev_data = [("path/to/test.htm.ini", [test_id], """[test.htm]
@@ -93,6 +97,7 @@ def test_update_1(self):
         self.assertFalse(new_manifest.is_empty)
         self.assertEquals(new_manifest.get_test(test_id).children[0].get("expected"), "FAIL")
 
+    @pytest.mark.xfail
     def test_new_subtest(self):
         test_id = "/path/to/test.htm"
         prev_data = [("path/to/test.htm.ini", [test_id], """[test.htm]
@@ -120,6 +125,7 @@ def test_new_subtest(self):
         self.assertEquals(new_manifest.get_test(test_id).children[0].get("expected"), "FAIL")
         self.assertEquals(new_manifest.get_test(test_id).children[1].get("expected"), "FAIL")
 
+    @pytest.mark.xfail
     def test_update_multiple_0(self):
         test_id = "/path/to/test.htm"
         prev_data = [("path/to/test.htm.ini", [test_id], """[test.htm]
@@ -159,6 +165,7 @@ def test_update_multiple_0(self):
         self.assertEquals(new_manifest.get_test(test_id).children[0].get(
             "expected", {"debug": False, "os": "linux"}), "TIMEOUT")
 
+    @pytest.mark.xfail
     def test_update_multiple_1(self):
         test_id = "/path/to/test.htm"
         prev_data = [("path/to/test.htm.ini", [test_id], """[test.htm]
@@ -200,6 +207,7 @@ def test_update_multiple_1(self):
         self.assertEquals(new_manifest.get_test(test_id).children[0].get(
             "expected", {"debug": False, "os": "windows"}), "FAIL")
 
+    @pytest.mark.xfail
     def test_update_multiple_2(self):
         test_id = "/path/to/test.htm"
         prev_data = [("path/to/test.htm.ini", [test_id], """[test.htm]
@@ -239,6 +247,7 @@ def test_update_multiple_2(self):
         self.assertEquals(new_manifest.get_test(test_id).children[0].get(
             "expected", {"debug": True, "os": "osx"}), "TIMEOUT")
 
+    @pytest.mark.xfail
     def test_update_multiple_3(self):
         test_id = "/path/to/test.htm"
         prev_data = [("path/to/test.htm.ini", [test_id], """[test.htm]
@@ -280,6 +289,7 @@ def test_update_multiple_3(self):
         self.assertEquals(new_manifest.get_test(test_id).children[0].get(
             "expected", {"debug": True, "os": "osx"}), "TIMEOUT")
 
+    @pytest.mark.xfail
     def test_update_ignore_existing(self):
         test_id = "/path/to/test.htm"
         prev_data = [("path/to/test.htm.ini", [test_id], """[test.htm]
diff --git a/tests/wpt/harness/wptrunner/webdriver_server.py b/tests/wpt/harness/wptrunner/webdriver_server.py
index 68d3fb7a3bfd..2ccb01d94367 100644
--- a/tests/wpt/harness/wptrunner/webdriver_server.py
+++ b/tests/wpt/harness/wptrunner/webdriver_server.py
@@ -16,7 +16,8 @@
 
 
 __all__ = ["SeleniumServer", "ChromeDriverServer",
-           "GeckoDriverServer", "WebDriverServer"]
+           "GeckoDriverServer", "ServoDriverServer",
+           "WebDriverServer"]
 
 
 class WebDriverServer(object):
@@ -86,9 +87,7 @@ def stop(self):
 
     @property
     def is_alive(self):
-        return (self._proc is not None and
-                self._proc.proc is not None and
-                self._proc.poll() is None)
+        return hasattr(self._proc, "proc") and self._proc.poll() is None
 
     def on_output(self, line):
         self.logger.process_output(self.pid,
@@ -154,6 +153,28 @@ def make_command(self):
                 "--webdriver-port", str(self.port)]
 
 
+class ServoDriverServer(WebDriverServer):
+    def __init__(self, logger, binary="servo", binary_args=None, host="127.0.0.1", port=None, render_backend=None):
+        env = os.environ.copy()
+        env["RUST_BACKTRACE"] = "1"
+        WebDriverServer.__init__(self, logger, binary, host=host, port=port, env=env)
+        self.binary_args = binary_args
+        self.render_backend = render_backend
+
+    def make_command(self):
+        command = [self.binary,
+                   "--webdriver", str(self.port),
+                   "--hard-fail",
+                   "--headless"]
+        if self.binary_args:
+            command += self.binary_args
+        if self.render_backend == "cpu":
+            command += ["--cpu"]
+        elif self.render_backend == "webrender":
+            command += ["--webrender"]
+        return command
+
+
 def cmd_arg(name, value=None):
     prefix = "-" if platform.system() == "Windows" else "--"
     rv = prefix + name
diff --git a/tests/wpt/harness/wptrunner/wptcommandline.py b/tests/wpt/harness/wptrunner/wptcommandline.py
index 3b059378e09a..fe8a24e87916 100644
--- a/tests/wpt/harness/wptrunner/wptcommandline.py
+++ b/tests/wpt/harness/wptrunner/wptcommandline.py
@@ -45,61 +45,33 @@ def create_parser(product_choices=None):
         config_data = config.load()
         product_choices = products.products_enabled(config_data)
 
-    parser = argparse.ArgumentParser(description="Runner for web-platform-tests tests.")
-    parser.add_argument("--metadata", action="store", type=abs_path, dest="metadata_root",
-                        help="Path to the folder containing test metadata"),
-    parser.add_argument("--tests", action="store", type=abs_path, dest="tests_root",
-                        help="Path to test files"),
-    parser.add_argument("--run-info", action="store", type=abs_path,
-                        help="Path to directory containing extra json files to add to run info")
-    parser.add_argument("--config", action="store", type=abs_path, dest="config",
-                        help="Path to config file")
+    parser = argparse.ArgumentParser(description="""Runner for web-platform-tests tests.""",
+                                     usage="""%(prog)s [OPTION]... [TEST]...
 
+TEST is either the full path to a test file to run, or the URL of a test excluding
+scheme host and port.""")
     parser.add_argument("--manifest-update", action="store_true", default=False,
-                        help="Force regeneration of the test manifest")
-
-    parser.add_argument("--binary", action="store",
-                        type=abs_path, help="Binary to run tests against")
-    parser.add_argument('--binary-arg',
-                        default=[], action="append", dest="binary_args",
-                        help="Extra argument for the binary (servo)")
-    parser.add_argument("--webdriver-binary", action="store", metavar="BINARY",
-                        type=abs_path, help="WebDriver server binary to use")
-    parser.add_argument("--processes", action="store", type=int, default=None,
-                        help="Number of simultaneous processes to use")
+                        help="Regenerate the test manifest.")
 
+    parser.add_argument("--timeout-multiplier", action="store", type=float, default=None,
+                        help="Multiplier relative to standard test timeout to use")
     parser.add_argument("--run-by-dir", type=int, nargs="?", default=False,
                         help="Split run into groups by directories. With a parameter,"
                         "limit the depth of splits e.g. --run-by-dir=1 to split by top-level"
                         "directory")
-
-    parser.add_argument("--timeout-multiplier", action="store", type=float, default=None,
-                        help="Multiplier relative to standard test timeout to use")
-    parser.add_argument("--repeat", action="store", type=int, default=1,
-                        help="Number of times to run the tests")
-    parser.add_argument("--repeat-until-unexpected", action="store_true", default=None,
-                        help="Run tests in a loop until one returns an unexpected result")
+    parser.add_argument("--processes", action="store", type=int, default=None,
+                        help="Number of simultaneous processes to use")
 
     parser.add_argument("--no-capture-stdio", action="store_true", default=False,
                         help="Don't capture stdio and write to logging")
 
-    parser.add_argument("--product", action="store", choices=product_choices,
-                        default=None, help="Browser against which to run tests")
-
-    parser.add_argument("--list-test-groups", action="store_true",
-                        default=False,
-                        help="List the top level directories containing tests that will run.")
-    parser.add_argument("--list-disabled", action="store_true",
-                        default=False,
-                        help="List the tests that are disabled on the current platform")
-
-    build_type = parser.add_mutually_exclusive_group()
-    build_type.add_argument("--debug-build", dest="debug", action="store_true",
-                            default=None,
-                            help="Build is a debug build (overrides any mozinfo file)")
-    build_type.add_argument("--release-build", dest="debug", action="store_false",
-                            default=None,
-                            help="Build is a release (overrides any mozinfo file)")
+    mode_group = parser.add_argument_group("Mode")
+    mode_group.add_argument("--list-test-groups", action="store_true",
+                            default=False,
+                            help="List the top level directories containing tests that will run.")
+    mode_group.add_argument("--list-disabled", action="store_true",
+                            default=False,
+                            help="List the tests that are disabled on the current platform")
 
     test_selection_group = parser.add_argument_group("Test Selection")
     test_selection_group.add_argument("--test-types", action="store",
@@ -119,7 +91,10 @@ def create_parser(product_choices=None):
     debugging_group.add_argument('--debugger', const="__default__", nargs="?",
                                  help="run under a debugger, e.g. gdb or valgrind")
     debugging_group.add_argument('--debugger-args', help="arguments to the debugger")
-
+    debugging_group.add_argument("--repeat", action="store", type=int, default=1,
+                                 help="Number of times to run the tests")
+    debugging_group.add_argument("--repeat-until-unexpected", action="store_true", default=None,
+                                 help="Run tests in a loop until one returns an unexpected result")
     debugging_group.add_argument('--pause-after-test', action="store_true", default=None,
                                  help="Halt the test runner after each test (this happens by default if only a single test is run)")
     debugging_group.add_argument('--no-pause-after-test', dest="pause_after_test", action="store_false",
@@ -133,6 +108,38 @@ def create_parser(product_choices=None):
     debugging_group.add_argument("--stackwalk-binary", action="store", type=abs_path,
                                  help="Path to stackwalker program used to analyse minidumps.")
 
+    debugging_group.add_argument("--pdb", action="store_true",
+                                 help="Drop into pdb on python exception")
+
+    config_group = parser.add_argument_group("Configuration")
+    config_group.add_argument("--binary", action="store",
+                              type=abs_path, help="Binary to run tests against")
+    config_group.add_argument('--binary-arg',
+                              default=[], action="append", dest="binary_args",
+                              help="Extra argument for the binary (servo)")
+    config_group.add_argument("--webdriver-binary", action="store", metavar="BINARY",
+                              type=abs_path, help="WebDriver server binary to use")
+
+    config_group.add_argument("--metadata", action="store", type=abs_path, dest="metadata_root",
+                              help="Path to root directory containing test metadata"),
+    config_group.add_argument("--tests", action="store", type=abs_path, dest="tests_root",
+                              help="Path to root directory containing test files"),
+    config_group.add_argument("--run-info", action="store", type=abs_path,
+                              help="Path to directory containing extra json files to add to run info")
+    config_group.add_argument("--product", action="store", choices=product_choices,
+                              default=None, help="Browser against which to run tests")
+    config_group.add_argument("--config", action="store", type=abs_path, dest="config",
+                              help="Path to config file")
+
+    build_type = parser.add_mutually_exclusive_group()
+    build_type.add_argument("--debug-build", dest="debug", action="store_true",
+                            default=None,
+                            help="Build is a debug build (overrides any mozinfo file)")
+    build_type.add_argument("--release-build", dest="debug", action="store_false",
+                            default=None,
+                            help="Build is a release (overrides any mozinfo file)")
+
+
     chunking_group = parser.add_argument_group("Test Chunking")
     chunking_group.add_argument("--total-chunks", action="store", type=int, default=1,
                                 help="Total number of chunks to use")
diff --git a/tests/wpt/harness/wptrunner/wptmanifest/tests/test_serializer.py b/tests/wpt/harness/wptrunner/wptmanifest/tests/test_serializer.py
index ec4d6e2d7373..62a462c44e72 100644
--- a/tests/wpt/harness/wptrunner/wptmanifest/tests/test_serializer.py
+++ b/tests/wpt/harness/wptrunner/wptmanifest/tests/test_serializer.py
@@ -2,10 +2,13 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this file,
 # You can obtain one at http://mozilla.org/MPL/2.0/.
 
+import sys
 import unittest
 
 from cStringIO import StringIO
 
+import pytest
+
 from .. import parser, serializer
 
 
@@ -196,6 +199,7 @@ def test_escape_8(self):
                      r"""key: "#"
 """)
 
+    @pytest.mark.xfail(sys.maxunicode == 0xFFFF, reason="narrow unicode")
     def test_escape_9(self):
         self.compare(r"""key: \U10FFFFabc""",
                      u"""key: \U0010FFFFabc
diff --git a/tests/wpt/harness/wptrunner/wpttest.py b/tests/wpt/harness/wptrunner/wpttest.py
index 9832f72654ea..7985b0e5f931 100644
--- a/tests/wpt/harness/wptrunner/wpttest.py
+++ b/tests/wpt/harness/wptrunner/wpttest.py
@@ -131,7 +131,7 @@ def from_manifest(cls, manifest_item, inherit_metadata, test_metadata):
                    inherit_metadata,
                    test_metadata,
                    timeout=timeout,
-                   path=manifest_item.path,
+                   path=manifest_item.source_file.path,
                    protocol="https" if hasattr(manifest_item, "https") and manifest_item.https else "http")
 
     @property