Backed out 4 changesets (bug 1323770) for marionette bustage a=backout
authorWes Kocher <wkocher@mozilla.com>
Wed, 28 Dec 2016 14:09:26 -0800
changeset 327419 9a78a4e9b5980d2f6b0f00252b1339318af01020
parent 327418 2b12bf8d14cfe2deab64120bbf575edde6e915dd
child 327420 daea17652fc8d9719ece049101b26047026657a4
push id35496
push userkwierso@gmail.com
push dateWed, 28 Dec 2016 22:09:40 +0000
treeherderautoland@9a78a4e9b598 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbackout
bugs1323770
milestone53.0a1
backs outbb8ccabdbe2746ad256f602a8a849d39c86ae28e
f1fbf0853e4f78a01102b47b4809c6058fb7723b
d0e5cb3af786de9ec377a1e58014fb9af7ead9c5
71e82343afb96f5c77f2030b21bb47700aa5dd20
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out 4 changesets (bug 1323770) for marionette bustage a=backout Backed out changeset bb8ccabdbe27 (bug 1323770) Backed out changeset f1fbf0853e4f (bug 1323770) Backed out changeset d0e5cb3af786 (bug 1323770) Backed out changeset 71e82343afb9 (bug 1323770)
testing/firefox-ui/tests/functional/security/test_ssl_status_after_restart.py
testing/marionette/harness/marionette_harness/marionette_test/__init__.py
testing/marionette/harness/marionette_harness/marionette_test/decorators.py
testing/marionette/harness/marionette_harness/marionette_test/errors.py
testing/marionette/harness/marionette_harness/marionette_test/testcases.py
testing/marionette/harness/marionette_harness/runner/base.py
testing/marionette/harness/marionette_harness/tests/unit/test_about_pages.py
testing/marionette/harness/marionette_harness/tests/unit/test_certificates.py
testing/marionette/harness/marionette_harness/tests/unit/test_click_scrolling.py
testing/marionette/harness/marionette_harness/tests/unit/test_crash.py
testing/marionette/harness/marionette_harness/tests/unit/test_element_state_chrome.py
testing/marionette/harness/marionette_harness/tests/unit/test_import_script.py
testing/marionette/harness/marionette_harness/tests/unit/test_modal_dialogs.py
testing/marionette/harness/marionette_harness/tests/unit/test_navigation.py
testing/marionette/harness/marionette_harness/tests/unit/test_screen_orientation.py
testing/marionette/harness/marionette_harness/tests/unit/test_single_finger_desktop.py
testing/marionette/harness/marionette_harness/tests/unit/test_text_chrome.py
testing/marionette/harness/marionette_harness/tests/unit/test_transport.py
testing/marionette/harness/marionette_harness/tests/unit/test_typing.py
testing/marionette/harness/marionette_harness/tests/unit/unit-tests.ini
testing/marionette/harness/requirements.txt
testing/mozbase/moztest/moztest/adapters/unit.py
testing/mozbase/moztest/setup.py
--- a/testing/firefox-ui/tests/functional/security/test_ssl_status_after_restart.py
+++ b/testing/firefox-ui/tests/functional/security/test_ssl_status_after_restart.py
@@ -41,17 +41,17 @@ class TestSSLStatusAfterRestart(Puppetee
             self.puppeteer.windows.close_all([self.browser])
             self.browser.tabbar.close_all_tabs([self.browser.tabbar.tabs[0]])
             self.browser.switch_to()
             self.identity_popup.close(force=True)
             self.marionette.clear_pref('browser.startup.page')
         finally:
             super(TestSSLStatusAfterRestart, self).tearDown()
 
-    @skip_if_e10s("Bug 1325047")
+    @skip_if_e10s
     def test_ssl_status_after_restart(self):
         for item in self.test_data:
             with self.marionette.using_context('content'):
                 self.marionette.navigate(item['url'])
             self.verify_certificate_status(item)
             self.browser.tabbar.open_tab()
 
         self.restart()
--- a/testing/marionette/harness/marionette_harness/marionette_test/__init__.py
+++ b/testing/marionette/harness/marionette_harness/marionette_test/__init__.py
@@ -1,30 +1,30 @@
 # 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/.
 
 __version__ = '3.1.0'
 
 
-from unittest.case import (
+from .decorators import (
     expectedFailure,
-    skip,
-    SkipTest,
-)
-
-from .decorators import (
     parameterized,
     run_if_e10s,
+    skip,
     skip_if_chrome,
     skip_if_desktop,
     skip_if_e10s,
     skip_if_mobile,
     skip_unless_browser_pref,
     skip_unless_protocol,
     with_parameters,
 )
 
+from .errors import (
+    SkipTest,
+)
+
 from .testcases import (
     CommonTestCase,
     MarionetteTestCase,
     MetaParameterized,
 )
--- a/testing/marionette/harness/marionette_harness/marionette_test/decorators.py
+++ b/testing/marionette/harness/marionette_harness/marionette_test/decorators.py
@@ -1,20 +1,35 @@
 # 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 functools
+import sys
 import types
 
-from unittest.case import (
+from .errors import (
+    _ExpectedFailure,
+    _UnexpectedSuccess,
     SkipTest,
 )
 
 
+def expectedFailure(func):
+    """Decorator which marks a test as expected fail."""
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            func(*args, **kwargs)
+        except Exception:
+            raise _ExpectedFailure(sys.exc_info())
+        raise _UnexpectedSuccess
+    return wrapper
+
+
 def parameterized(func_suffix, *args, **kwargs):
     r"""Decorator which generates methods given a base method and some data.
 
     **func_suffix** is used as a suffix for the new created method and must be
     unique given a base method. if **func_suffix** countains characters that
     are not allowed in normal python function name, these characters will be
     replaced with "_".
 
@@ -41,161 +56,132 @@ def parameterized(func_suffix, *args, **
     def wrapped(func):
         if not hasattr(func, 'metaparameters'):
             func.metaparameters = []
         func.metaparameters.append((func_suffix, args, kwargs))
         return func
     return wrapped
 
 
-def run_if_e10s(reason):
+def run_if_e10s(target):
     """Decorator which runs a test if e10s mode is active."""
-    def decorator(test_item):
-        if not isinstance(test_item, types.FunctionType):
-            raise Exception('Decorator only supported for functions')
+    def wrapper(self, *args, **kwargs):
+        with self.marionette.using_context('chrome'):
+            multi_process_browser = self.marionette.execute_script("""
+            try {
+              return Services.appinfo.browserTabsRemoteAutostart;
+            } catch (e) {
+              return false;
+            }""")
 
-        @functools.wraps(test_item)
-        def skip_wrapper(self, *args, **kwargs):
-            with self.marionette.using_context('chrome'):
-                multi_process_browser = not self.marionette.execute_script("""
-                    try {
-                      return Services.appinfo.browserTabsRemoteAutostart;
-                    } catch (e) {
-                      return false;
-                    }
-                """)
-                if multi_process_browser:
-                    raise SkipTest(reason)
-            return test_item(self, *args, **kwargs)
-        return skip_wrapper
-    return decorator
+        if not multi_process_browser:
+            raise SkipTest('skipping due to e10s is disabled')
+        return target(self, *args, **kwargs)
+    return wrapper
 
 
-def skip_if_chrome(reason):
-    """Decorator which skips a test if chrome context is active."""
+def skip(reason):
+    """Decorator which unconditionally skips a test."""
     def decorator(test_item):
-        if not isinstance(test_item, types.FunctionType):
-            raise Exception('Decorator only supported for functions')
+        if not isinstance(test_item, (type, types.ClassType)):
+            @functools.wraps(test_item)
+            def skip_wrapper(*args, **kwargs):
+                raise SkipTest(reason)
+            test_item = skip_wrapper
 
-        @functools.wraps(test_item)
-        def skip_wrapper(self, *args, **kwargs):
-            if self.marionette._send_message('getContext', key='value') == 'chrome':
-                raise SkipTest(reason)
-            return test_item(self, *args, **kwargs)
-        return skip_wrapper
+        test_item.__unittest_skip__ = True
+        test_item.__unittest_skip_why__ = reason
+        return test_item
     return decorator
 
 
-def skip_if_desktop(reason):
-    """Decorator which skips a test if run on desktop."""
-    def decorator(test_item):
-        if not isinstance(test_item, types.FunctionType):
-            raise Exception('Decorator only supported for functions')
+def skip_if_chrome(target):
+    """Decorator which skips a test if chrome context is active."""
+    def wrapper(self, *args, **kwargs):
+        if self.marionette._send_message("getContext", key="value") == "chrome":
+            raise SkipTest("skipping test in chrome context")
+        return target(self, *args, **kwargs)
+    return wrapper
 
-        @functools.wraps(test_item)
-        def skip_wrapper(self, *args, **kwargs):
-            if self.marionette.session_capabilities.get('browserName') == 'firefox':
-                raise SkipTest(reason)
-            return test_item(self, *args, **kwargs)
-        return skip_wrapper
-    return decorator
+
+def skip_if_desktop(target):
+    """Decorator which skips a test if run on desktop."""
+    def wrapper(self, *args, **kwargs):
+        if self.marionette.session_capabilities.get('browserName') == 'firefox':
+            raise SkipTest('skipping due to desktop')
+        return target(self, *args, **kwargs)
+    return wrapper
 
 
-def skip_if_e10s(reason):
+def skip_if_e10s(target):
     """Decorator which skips a test if e10s mode is active."""
-    def decorator(test_item):
-        if not isinstance(test_item, types.FunctionType):
-            raise Exception('Decorator only supported for functions')
+    def wrapper(self, *args, **kwargs):
+        with self.marionette.using_context('chrome'):
+            multi_process_browser = self.marionette.execute_script("""
+            try {
+              return Services.appinfo.browserTabsRemoteAutostart;
+            } catch (e) {
+              return false;
+            }""")
 
-        @functools.wraps(test_item)
-        def skip_wrapper(self, *args, **kwargs):
-            with self.marionette.using_context('chrome'):
-                multi_process_browser = self.marionette.execute_script("""
-                    try {
-                      return Services.appinfo.browserTabsRemoteAutostart;
-                    } catch (e) {
-                      return false;
-                    }
-                """)
-                if multi_process_browser:
-                    raise SkipTest(reason)
-            return test_item(self, *args, **kwargs)
-        return skip_wrapper
-    return decorator
+        if multi_process_browser:
+            raise SkipTest('skipping due to e10s')
+        return target(self, *args, **kwargs)
+    return wrapper
 
 
-def skip_if_mobile(reason):
+def skip_if_mobile(target):
     """Decorator which skips a test if run on mobile."""
-    def decorator(test_item):
-        if not isinstance(test_item, types.FunctionType):
-            raise Exception('Decorator only supported for functions')
-
-        @functools.wraps(test_item)
-        def skip_wrapper(self, *args, **kwargs):
-            if self.marionette.session_capabilities.get('browserName') == 'fennec':
-                raise SkipTest(reason)
-            return test_item(self, *args, **kwargs)
-        return skip_wrapper
-    return decorator
+    def wrapper(self, *args, **kwargs):
+        if self.marionette.session_capabilities.get('browserName') == 'fennec':
+            raise SkipTest('skipping due to fennec')
+        return target(self, *args, **kwargs)
+    return wrapper
 
 
-def skip_unless_browser_pref(reason, pref, predicate=bool):
+def skip_unless_browser_pref(pref, predicate=bool):
     """Decorator which skips a test based on the value of a browser preference.
 
-    :param reason: Message describing why the test need to be skipped.
     :param pref: the preference name
     :param predicate: a function that should return false to skip the test.
                       The function takes one parameter, the preference value.
                       Defaults to the python built-in bool function.
 
     Note that the preference must exist, else a failure is raised.
 
     Example: ::
 
       class TestSomething(MarionetteTestCase):
-          @skip_unless_browser_pref("Sessionstore needs to be enabled for crashes",
-                                    "browser.sessionstore.resume_from_crash",
-                                    lambda value: value is True,
-                                    )
+          @skip_unless_browser_pref("accessibility.tabfocus",
+                                    lambda value: value >= 7)
           def test_foo(self):
               pass  # test implementation here
-
     """
-    def decorator(test_item):
-        if not isinstance(test_item, types.FunctionType):
-            raise Exception('Decorator only supported for functions')
-        if not callable(predicate):
-            raise ValueError('predicate must be callable')
-
-        @functools.wraps(test_item)
-        def skip_wrapper(self, *args, **kwargs):
+    def wrapper(target):
+        @functools.wraps(target)
+        def wrapped(self, *args, **kwargs):
             value = self.marionette.get_pref(pref)
             if value is None:
                 self.fail("No such browser preference: {0!r}".format(pref))
             if not predicate(value):
-                raise SkipTest(reason)
-            return test_item(self, *args, **kwargs)
-        return skip_wrapper
-    return decorator
+                raise SkipTest("browser preference {0!r}: {1!r}".format((pref, value)))
+            return target(self, *args, **kwargs)
+        return wrapped
+    return wrapper
 
 
-def skip_unless_protocol(reason, predicate):
+def skip_unless_protocol(predicate):
     """Decorator which skips a test if the predicate does not match the current protocol level."""
     def decorator(test_item):
-        if not isinstance(test_item, types.FunctionType):
-            raise Exception('Decorator only supported for functions')
-        if not callable(predicate):
-            raise ValueError('predicate must be callable')
-
         @functools.wraps(test_item)
-        def skip_wrapper(self, *args, **kwargs):
+        def skip_wrapper(self):
             level = self.marionette.client.protocol
             if not predicate(level):
-                raise SkipTest(reason)
-            return test_item(self, *args, **kwargs)
+                raise SkipTest('skipping because protocol level is {}'.format(level))
+            return test_item(self)
         return skip_wrapper
     return decorator
 
 
 def with_parameters(parameters):
     """Decorator which generates methods given a base method and some data.
 
     Acts like :func:`parameterized`, but define all methods in one call.
new file mode 100644
--- /dev/null
+++ b/testing/marionette/harness/marionette_harness/marionette_test/errors.py
@@ -0,0 +1,32 @@
+# 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/.
+
+
+class SkipTest(Exception):
+    """
+    Raise this exception in a test to skip it.
+
+    Usually you can use TestResult.skip() or one of the skipping decorators
+    instead of raising this directly.
+    """
+
+    pass
+
+
+class _ExpectedFailure(Exception):
+    """
+    Raise this when a test is expected to fail.
+
+    This is an implementation detail.
+    """
+
+    def __init__(self, exc_info):
+        super(_ExpectedFailure, self).__init__()
+        self.exc_info = exc_info
+
+
+class _UnexpectedSuccess(Exception):
+    """The test was supposed to fail, but it didn't."""
+
+    pass
--- a/testing/marionette/harness/marionette_harness/marionette_test/testcases.py
+++ b/testing/marionette/harness/marionette_harness/marionette_test/testcases.py
@@ -7,29 +7,29 @@ import os
 import re
 import sys
 import time
 import types
 import unittest
 import warnings
 import weakref
 
-from unittest.case import (
-    _ExpectedFailure,
-    _UnexpectedSuccess,
-    SkipTest,
-)
-
 from marionette_driver.errors import (
     MarionetteException,
     ScriptTimeoutException,
     TimeoutException,
 )
 from mozlog import get_default_logger
 
+from .errors import (
+    _ExpectedFailure,
+    _UnexpectedSuccess,
+    SkipTest,
+)
+
 
 def _wraps_parameterized(func, func_suffix, args, kwargs):
     """Internal: Decorator used in class MetaParameterized."""
     def wrapper(self):
         return func(self, *args, **kwargs)
     wrapper.__name__ = func.__name__ + '_' + str(func_suffix)
     wrapper.__doc__ = '[{0}] {1}'.format(func_suffix, func.__doc__)
     return wrapper
--- a/testing/marionette/harness/marionette_harness/runner/base.py
+++ b/testing/marionette/harness/marionette_harness/runner/base.py
@@ -547,20 +547,16 @@ class BaseMarionetteTestRunner(object):
         self.workspace = workspace
         # If no workspace is set, default location for gecko.log is .
         # and default location for profile is TMP
         self.workspace_path = workspace or os.getcwd()
         self.verbose = verbose
         self.e10s = e10s
 
         def gather_debug(test, status):
-            # No screenshots and page source for skipped tests
-            if status == "SKIP":
-                return
-
             rv = {}
             marionette = test._marionette_weakref()
 
             # In the event we're gathering debug without starting a session,
             # skip marionette commands
             if marionette.session is not None:
                 try:
                     with marionette.using_context(marionette.CONTEXT_CHROME):
--- a/testing/marionette/harness/marionette_harness/tests/unit/test_about_pages.py
+++ b/testing/marionette/harness/marionette_harness/tests/unit/test_about_pages.py
@@ -21,17 +21,17 @@ class TestAboutPages(WindowManagerMixin,
         self.remote_uri = self.marionette.absolute_url("javascriptPage.html")
         self.marionette.navigate(self.remote_uri)
 
     def tearDown(self):
         self.close_all_tabs()
 
         super(TestAboutPages, self).tearDown()
 
-    @skip_if_mobile("Bug 1323185 - Add Fennec support to getWindowHandles")
+    @skip_if_mobile  # Bug 1323185 - Add Fennec support to getWindowHandles
     def test_back_forward(self):
         # Bug 1311041 - Prevent changing of window handle by forcing the test
         # to be run in a new tab.
         new_tab = self.open_tab(trigger='menu')
         self.marionette.switch_to_window(new_tab)
 
         self.marionette.navigate("about:blank")
         self.marionette.navigate(self.remote_uri)
@@ -41,74 +41,74 @@ class TestAboutPages(WindowManagerMixin,
         self.marionette.go_back()
 
         self.wait_for_condition(
             lambda mn: mn.get_url() == self.remote_uri)
 
         self.marionette.close()
         self.marionette.switch_to_window(self.start_tab)
 
-    @skip_if_mobile("Bug 1323185 - Add Fennec support to getWindowHandles")
+    @skip_if_mobile  # Bug 1323185 - Add Fennec support to getWindowHandles
     def test_navigate_non_remote_about_pages(self):
         # Bug 1311041 - Prevent changing of window handle by forcing the test
         # to be run in a new tab.
         new_tab = self.open_tab(trigger='menu')
         self.marionette.switch_to_window(new_tab)
 
         self.marionette.navigate("about:blank")
         self.assertEqual(self.marionette.get_url(), "about:blank")
         self.marionette.navigate("about:preferences")
         self.assertEqual(self.marionette.get_url(), "about:preferences")
 
         self.marionette.close()
         self.marionette.switch_to_window(self.start_tab)
 
-    @skip_if_mobile("On Android no shortcuts are available")
+    @skip_if_mobile  # On Android no shortcuts are available
     def test_navigate_shortcut_key(self):
         def open_with_shortcut():
             with self.marionette.using_context("chrome"):
                 main_win = self.marionette.find_element(By.ID, "main-window")
                 main_win.send_keys(self.mod_key, Keys.SHIFT, 'a')
 
         new_tab = self.open_tab(trigger=open_with_shortcut)
         self.marionette.switch_to_window(new_tab)
 
         self.wait_for_condition(lambda mn: mn.get_url() == "about:addons")
 
         self.marionette.close()
         self.marionette.switch_to_window(self.start_tab)
 
-    @skip_if_mobile("Bug 1323185 - Add Fennec support to getWindowHandles")
+    @skip_if_mobile  # Bug 1323185 - Add Fennec support to getWindowHandles
     def test_type_to_non_remote_tab(self):
         # Bug 1311041 - Prevent changing of window handle by forcing the test
         # to be run in a new tab.
         new_tab = self.open_tab(trigger='menu')
         self.marionette.switch_to_window(new_tab)
 
         with self.marionette.using_context("chrome"):
             urlbar = self.marionette.find_element(By.ID, 'urlbar')
             urlbar.send_keys(self.mod_key + 'a')
             urlbar.send_keys(self.mod_key + 'x')
             urlbar.send_keys('about:preferences' + Keys.ENTER)
         self.wait_for_condition(lambda mn: mn.get_url() == "about:preferences")
 
         self.marionette.close()
         self.marionette.switch_to_window(self.start_tab)
 
-    @skip_if_mobile("Interacting with chrome elements not available for Fennec")
+    @skip_if_mobile  # Interacting with chrome elements not available for Fennec
     def test_type_to_remote_tab(self):
         # about:blank keeps remoteness from remote_uri
         self.marionette.navigate("about:blank")
         with self.marionette.using_context("chrome"):
             urlbar = self.marionette.find_element(By.ID, 'urlbar')
             urlbar.send_keys(self.remote_uri + Keys.ENTER)
 
         self.wait_for_condition(lambda mn: mn.get_url() == self.remote_uri)
 
-    @skip_if_mobile("Bug 1323185 - Add Fennec support to getWindowHandles")
+    @skip_if_mobile  # Bug 1323185 - Add Fennec support to getWindowHandles
     def test_hang(self):
         # Open a new tab and close the first one
         new_tab = self.open_tab(trigger="menu")
 
         self.marionette.close()
         self.marionette.switch_to_window(new_tab)
 
         self.marionette.navigate(self.remote_uri)
--- a/testing/marionette/harness/marionette_harness/tests/unit/test_certificates.py
+++ b/testing/marionette/harness/marionette_harness/tests/unit/test_certificates.py
@@ -1,34 +1,32 @@
 # 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/.
 
 from marionette_driver.errors import UnknownException
 
-from marionette_harness import MarionetteTestCase, skip
+from marionette_harness import MarionetteTestCase
 
 
 class TestCertificates(MarionetteTestCase):
-
-    @skip("Bug 1325079")
     def test_block_insecure_sites(self):
         self.marionette.delete_session()
         self.marionette.start_session()
 
         self.marionette.navigate(self.fixtures.where_is("test.html", on="http"))
         self.assertIn("http://", self.marionette.get_url())
         with self.assertRaises(UnknownException):
             self.marionette.navigate(self.fixtures.where_is("test.html", on="https"))
 
-    @skip("Bug 1325079")
     def test_accept_all_insecure(self):
         self.marionette.delete_session()
         self.marionette.start_session({"desiredCapability": {"acceptSslCerts": ["*"]}})
         self.marionette.navigate(self.fixtures.where_is("test.html", on="https"))
         self.assertIn("https://", self.marionette.url)
 
-    @skip("Bug 1325079")
+    """
     def test_accept_some_insecure(self):
         self.marionette.delete_session()
         self.marionette.start_session({"requiredCapabilities": {"acceptSslCerts": ["127.0.0.1"]}})
         self.marionette.navigate(self.fixtures.where_is("test.html", on="https"))
         self.assertIn("https://", self.marionette.url)
+    """
\ No newline at end of file
--- a/testing/marionette/harness/marionette_harness/tests/unit/test_click_scrolling.py
+++ b/testing/marionette/harness/marionette_harness/tests/unit/test_click_scrolling.py
@@ -38,17 +38,17 @@ class TestClickScrolling(MarionetteTestC
         self.marionette.navigate(test_html)
 
         link = self.marionette.find_element(By.ID, "link")
         try:
             link.click()
         except MoveTargetOutOfBoundsException:
             self.fail("Should not be out of bounds")
 
-    @skip("Bug 1200197 - Cannot interact with elements hidden inside overflow:scroll")
+    @skip("Bug 1003682")
     def test_should_be_able_to_click_on_an_element_hidden_by_overflow(self):
         test_html = self.marionette.absolute_url("scroll.html")
         self.marionette.navigate(test_html)
 
         link = self.marionette.find_element(By.ID, "line8")
         link.click()
         self.assertEqual("line8", self.marionette.find_element(By.ID, "clicked").text)
 
--- a/testing/marionette/harness/marionette_harness/tests/unit/test_crash.py
+++ b/testing/marionette/harness/marionette_harness/tests/unit/test_crash.py
@@ -99,17 +99,17 @@ class TestCrash(BaseCrashTestCase):
 
         self.marionette.start_session()
         self.assertNotEqual(self.marionette.process_id, self.pid)
 
         # TODO: Bug 1314594 - Causes a hang for the communication between the
         # chrome and frame script.
         # self.marionette.get_url()
 
-    @run_if_e10s("Content crashes only exist in e10s mode")
+    @run_if_e10s
     def test_crash_content_process(self):
         # If e10s is disabled the chrome process crashes
         self.marionette.navigate(self.remote_uri)
 
         self.assertRaisesRegexp(IOError, 'Content process crashed',
                                 self.crash, chrome=False)
         self.assertEqual(self.marionette.crashed, 1)
         self.assertIsNone(self.marionette.session)
--- a/testing/marionette/harness/marionette_harness/tests/unit/test_element_state_chrome.py
+++ b/testing/marionette/harness/marionette_harness/tests/unit/test_element_state_chrome.py
@@ -1,15 +1,15 @@
 # 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/.
 
 from marionette_driver.by import By
 
-from marionette_harness import MarionetteTestCase, skip
+from marionette_harness import MarionetteTestCase
 
 
 class TestIsElementEnabledChrome(MarionetteTestCase):
     def setUp(self):
         MarionetteTestCase.setUp(self)
         self.marionette.set_context("chrome")
         self.win = self.marionette.current_window_handle
         self.marionette.execute_script("window.open('chrome://marionette/content/test.xul', 'foo', 'chrome,centerscreen');")
@@ -31,24 +31,27 @@ class TestIsElementEnabledChrome(Marione
 
     def test_can_get_element_rect(self):
         l = self.marionette.find_element(By.ID, "textInput")
         rect = l.rect
         self.assertTrue(rect['x'] > 0)
         self.assertTrue(rect['y'] > 0)
 
 
-@skip("Switched off in bug 896043, and to be turned on in bug 896046")
+# Switched off in bug 896043,
+# and to be turned on in bug 896046
+"""
 class TestIsElementDisplayed(MarionetteTestCase):
     def test_isDisplayed(self):
         l = self.marionette.find_element(By.ID, "textInput")
         self.assertTrue(l.is_displayed())
         self.marionette.execute_script("arguments[0].hidden = true;", [l])
         self.assertFalse(l.is_displayed())
         self.marionette.execute_script("arguments[0].hidden = false;", [l])
+"""
 
 
 class TestGetElementAttributeChrome(MarionetteTestCase):
     def setUp(self):
         MarionetteTestCase.setUp(self)
         self.marionette.set_context("chrome")
         self.win = self.marionette.current_window_handle
         self.marionette.execute_script("window.open('chrome://marionette/content/test.xul', 'foo', 'chrome,centerscreen');")
--- a/testing/marionette/harness/marionette_harness/tests/unit/test_import_script.py
+++ b/testing/marionette/harness/marionette_harness/tests/unit/test_import_script.py
@@ -26,21 +26,16 @@ class TestImportScriptContent(WindowMana
     def setUp(self):
         super(TestImportScriptContent, self).setUp()
 
         for context in self.contexts:
             with self.marionette.using_context(context):
                 self.marionette.clear_imported_scripts()
         self.reset_context()
 
-    def tearDown(self):
-        self.close_all_windows()
-
-        super(TestImportScriptContent, self).tearDown()
-
     def reset_context(self):
         self.marionette.set_context("content")
 
     @property
     def current_context(self):
         return self.marionette._send_message("getContext", key="value")
 
     @property
@@ -109,18 +104,18 @@ class TestImportScriptContent(WindowMana
         self.assert_defined("testFunc")
 
     def test_multiple_imports(self):
         self.marionette.import_script(self.script_file)
         self.marionette.import_script(self.another_script_file)
         self.assert_defined("testFunc")
         self.assert_defined("testAnotherFunc")
 
-    @skip_if_chrome("Needs content scope")
-    @skip_if_mobile("New windows not supported in Fennec")
+    @skip_if_chrome
+    @skip_if_mobile  # New windows not supported in Fennec
     def test_imports_apply_globally(self):
         self.marionette.navigate(
             self.marionette.absolute_url("test_windows.html"))
 
         def open_window_with_link():
             self.marionette.find_element(By.LINK_TEXT, "Open new window").click()
 
         new_window = self.open_window(trigger=open_window_with_link)
--- a/testing/marionette/harness/marionette_harness/tests/unit/test_modal_dialogs.py
+++ b/testing/marionette/harness/marionette_harness/tests/unit/test_modal_dialogs.py
@@ -152,17 +152,17 @@ class TestTabModals(MarionetteTestCase):
             """))
         self.marionette.navigate("about:blank")
         self.wait_for_alert()
         alert = self.marionette.switch_to_alert()
         self.assertTrue(alert.text.startswith("This page is asking you to confirm"))
         alert.accept()
         self.wait_for_condition(lambda mn: mn.get_url() == "about:blank")
 
-    @skip_if_e10s("Bug 1325044")
+    @skip_if_e10s
     def test_unrelated_command_when_alert_present(self):
         click_handler = self.marionette.find_element(By.ID, 'click-handler')
         text = self.marionette.find_element(By.ID, 'click-result').text
         self.assertEqual(text, '')
 
         self.marionette.find_element(By.ID, 'modal-alert').click()
         self.wait_for_alert()
 
--- a/testing/marionette/harness/marionette_harness/tests/unit/test_navigation.py
+++ b/testing/marionette/harness/marionette_harness/tests/unit/test_navigation.py
@@ -1,23 +1,21 @@
 # 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/.
 
+from unittest import skip
+
 import contextlib
 import time
 import urllib
 
 from marionette_driver import errors, By, Wait
-from marionette_harness import (
-    MarionetteTestCase,
-    skip,
-    skip_if_mobile,
-    WindowManagerMixin,
-)
+
+from marionette_harness import MarionetteTestCase, skip_if_mobile, WindowManagerMixin
 
 
 def inline(doc):
     return "data:text/html;charset=utf-8,%s" % urllib.quote(doc)
 
 
 class TestNavigate(WindowManagerMixin, MarionetteTestCase):
 
@@ -109,17 +107,17 @@ class TestNavigate(WindowManagerMixin, M
     def test_navigate_frame(self):
         self.marionette.navigate(self.marionette.absolute_url("test_iframe.html"))
         self.marionette.switch_to_frame(0)
         self.marionette.navigate(self.marionette.absolute_url("empty.html"))
         self.assertTrue('empty.html' in self.marionette.get_url())
         self.marionette.switch_to_frame()
         self.assertTrue('test_iframe.html' in self.marionette.get_url())
 
-    @skip_if_mobile("Bug 1323755 - Socket timeout")
+    @skip_if_mobile  # Bug 1323755 - Socket timeout
     def test_invalid_protocol(self):
         with self.assertRaises(errors.MarionetteException):
             self.marionette.navigate("thisprotocoldoesnotexist://")
 
     def test_should_navigate_to_requested_about_page(self):
         self.marionette.navigate("about:neterror")
         self.assertEqual(self.marionette.get_url(), "about:neterror")
         self.marionette.navigate(self.marionette.absolute_url("test.html"))
@@ -147,17 +145,17 @@ class TestNavigate(WindowManagerMixin, M
     def test_fragment(self):
         doc = inline("<p id=foo>")
         self.marionette.navigate(doc)
         self.marionette.execute_script("window.visited = true", sandbox=None)
         self.marionette.navigate("%s#foo" % doc)
         self.assertTrue(self.marionette.execute_script(
             "return window.visited", sandbox=None))
 
-    @skip_if_mobile("Fennec doesn't support other chrome windows")
+    @skip_if_mobile  # Fennec doesn't support other chrome windows
     def test_about_blank_for_new_docshell(self):
         """ Bug 1312674 - Hang when loading about:blank for a new docshell."""
         # Open a window to get a new docshell created for the first tab
         with self.marionette.using_context("chrome"):
             tab = self.open_tab(lambda: self.marionette.execute_script(" window.open() "))
             self.marionette.switch_to_window(tab)
 
         self.marionette.navigate('about:blank')
--- a/testing/marionette/harness/marionette_harness/tests/unit/test_screen_orientation.py
+++ b/testing/marionette/harness/marionette_harness/tests/unit/test_screen_orientation.py
@@ -18,69 +18,69 @@ class TestScreenOrientation(MarionetteTe
         self.is_mobile = self.marionette.session_capabilities.get("rotatable", False)
 
     def tearDown(self):
         if self.is_mobile:
             self.marionette.set_orientation(default_orientation)
             self.assertEqual(self.marionette.orientation, default_orientation, "invalid state")
         MarionetteTestCase.tearDown(self)
 
-    @skip_if_desktop("Not supported in Firefox")
+    @skip_if_desktop
     def test_set_orientation_to_portrait_primary(self):
         self.marionette.set_orientation("portrait-primary")
         new_orientation = self.marionette.orientation
         self.assertEqual(new_orientation, "portrait-primary")
 
-    @skip_if_desktop("Not supported in Firefox")
+    @skip_if_desktop
     def test_set_orientation_to_landscape_primary(self):
         self.marionette.set_orientation("landscape-primary")
         new_orientation = self.marionette.orientation
         self.assertEqual(new_orientation, "landscape-primary")
 
-    @skip_if_desktop("Not supported in Firefox")
+    @skip_if_desktop
     def test_set_orientation_to_portrait_secondary(self):
         self.marionette.set_orientation("portrait-secondary")
         new_orientation = self.marionette.orientation
         self.assertEqual(new_orientation, "portrait-secondary")
 
-    @skip_if_desktop("Not supported in Firefox")
+    @skip_if_desktop
     def test_set_orientation_to_landscape_secondary(self):
         self.marionette.set_orientation("landscape-secondary")
         new_orientation = self.marionette.orientation
         self.assertEqual(new_orientation, "landscape-secondary")
 
-    @skip_if_desktop("Not supported in Firefox")
+    @skip_if_desktop
     def test_set_orientation_to_shorthand_portrait(self):
         # Set orientation to something other than portrait-primary first, since the default is
         # portrait-primary.
         self.marionette.set_orientation("landscape-primary")
         self.assertEqual(self.marionette.orientation, "landscape-primary", "invalid state")
 
         self.marionette.set_orientation("portrait")
         new_orientation = self.marionette.orientation
         self.assertEqual(new_orientation, "portrait-primary")
 
-    @skip_if_desktop("Not supported in Firefox")
+    @skip_if_desktop
     def test_set_orientation_to_shorthand_landscape(self):
         self.marionette.set_orientation("landscape")
         new_orientation = self.marionette.orientation
         self.assertEqual(new_orientation, "landscape-primary")
 
-    @skip_if_desktop("Not supported in Firefox")
+    @skip_if_desktop
     def test_set_orientation_with_mixed_casing(self):
         self.marionette.set_orientation("lAnDsCaPe")
         new_orientation = self.marionette.orientation
         self.assertEqual(new_orientation, "landscape-primary")
 
-    @skip_if_desktop("Not supported in Firefox")
+    @skip_if_desktop
     def test_set_invalid_orientation(self):
         with self.assertRaisesRegexp(errors.MarionetteException, unknown_orientation.format("cheese")):
             self.marionette.set_orientation("cheese")
 
-    @skip_if_desktop("Not supported in Firefox")
+    @skip_if_desktop
     def test_set_null_orientation(self):
         with self.assertRaisesRegexp(errors.MarionetteException, unknown_orientation.format("null")):
             self.marionette.set_orientation(None)
 
-    @skip_if_mobile("Specific test for Firefox")
+    @skip_if_mobile
     def test_unsupported_operation_on_desktop(self):
         with self.assertRaises(errors.UnsupportedOperationException):
             self.marionette.set_orientation("landscape-primary")
--- a/testing/marionette/harness/marionette_harness/tests/unit/test_single_finger_desktop.py
+++ b/testing/marionette/harness/marionette_harness/tests/unit/test_single_finger_desktop.py
@@ -1,19 +1,19 @@
 # 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 os
 import sys
 
 from marionette_driver.errors import MarionetteException
-from marionette_driver import Actions, By
+from marionette_driver.by import By
 
-from marionette_harness import MarionetteTestCase, skip
+from marionette_harness import MarionetteTestCase
 
 # add this directory to the path
 sys.path.append(os.path.dirname(__file__))
 
 from single_finger_functions import (
     chain, chain_flick, context_menu, double_tap,
     long_press_action, long_press_on_xy_action,
     move_element, move_element_offset, press_release, single_tap, wait,
@@ -80,40 +80,38 @@ prefs.setIntPref("ui.click_hold_context_
         move_element_offset(self.marionette, self.wait_for_condition, "button1-mousemove-mousedown", "button2-mousemove-mouseup")
 
     def test_wait(self):
         wait(self.marionette, self.wait_for_condition, "button1-mousemove-mousedown-mouseup-click")
 
     def test_wait_with_value(self):
         wait_with_value(self.marionette, self.wait_for_condition, "button1-mousemove-mousedown-mouseup-click")
 
-    @skip("Bug 1191066")
+    """
+    // Skipping due to Bug 1191066
     def test_context_menu(self):
-        context_menu(self.marionette, self.wait_for_condition,
-                     "button1-mousemove-mousedown-contextmenu",
-                     "button1-mousemove-mousedown-contextmenu-mouseup-click")
+        context_menu(self.marionette, self.wait_for_condition, "button1-mousemove-mousedown-contextmenu", "button1-mousemove-mousedown-contextmenu-mouseup-click")
 
-    @skip("Bug 1191066")
     def test_long_press_action(self):
-        long_press_action(self.marionette, self.wait_for_condition,
-                          "button1-mousemove-mousedown-contextmenu-mouseup-click")
+        long_press_action(self.marionette, self.wait_for_condition, "button1-mousemove-mousedown-contextmenu-mouseup-click")
 
-    @skip("Bug 1191066")
     def test_long_press_on_xy_action(self):
-        long_press_on_xy_action(self.marionette, self.wait_for_condition,
-                                "button1-mousemove-mousedown-contextmenu-mouseup-click")
+        long_press_on_xy_action(self.marionette, self.wait_for_condition, "button1-mousemove-mousedown-contextmenu-mouseup-click")
+    """
 
-    @skip("Bug 865334")
+    """
+    //Skipping due to Bug 865334
     def test_long_press_fail(self):
         testAction = self.marionette.absolute_url("testAction.html")
         self.marionette.navigate(testAction)
         button = self.marionette.find_element(By.ID, "button1Copy")
         action = Actions(self.marionette)
         action.press(button).long_press(button, 5)
-        self.assertRaises(MarionetteException, action.perform)
+        assertRaises(MarionetteException, action.perform)
+    """
 
     def test_chain(self):
         chain(self.marionette, self.wait_for_condition, "button1-mousemove-mousedown", "delayed-mousemove-mouseup")
 
     def test_chain_flick(self):
         chain_flick(self.marionette, self.wait_for_condition, "button1-mousemove-mousedown-mousemove", "buttonFlick-mousemove-mouseup")
 
     def test_single_tap(self):
--- a/testing/marionette/harness/marionette_harness/tests/unit/test_text_chrome.py
+++ b/testing/marionette/harness/marionette_harness/tests/unit/test_text_chrome.py
@@ -1,18 +1,18 @@
 # 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/.
 
 from marionette_driver.by import By
 
-from marionette_harness import MarionetteTestCase, skip, WindowManagerMixin
+from marionette_harness import MarionetteTestCase, WindowManagerMixin
 
 
-@skip("Disabled in bug 896043 and when working on Chrome code re-enable for bug 896046")
+''' Disabled in bug 896043 and when working on Chrome code re-enable for bug 896046
 class TestTextChrome(WindowManagerMixin, MarionetteTestCase):
 
     def setUp(self):
         super(TestTextChrome, self).setUp()
         self.marionette.set_context("chrome")
 
         def open_window_with_js():
             self.marionette.execute_script("""
@@ -37,8 +37,9 @@ class TestTextChrome(WindowManagerMixin,
         box.clear()
         self.assertEqual("", box.text)
 
     def test_sendKeys(self):
         box = self.marionette.find_element(By.ID, "textInput")
         self.assertEqual("test", box.text)
         box.send_keys("at")
         self.assertEqual("attest", box.text)
+'''
--- a/testing/marionette/harness/marionette_harness/tests/unit/test_transport.py
+++ b/testing/marionette/harness/marionette_harness/tests/unit/test_transport.py
@@ -28,24 +28,24 @@ class TestMessageSequencing(MarionetteTe
         self.marionette.client.last_id = new_id
 
     def send(self, name, params):
         self.last_id = self.last_id + 1
         cmd = Command(self.last_id, name, params)
         self.marionette.client.send(cmd)
         return self.last_id
 
-    @skip_unless_protocol("Skip for level < 3", lambda level: level >= 3)
+    @skip_unless_protocol(lambda level: level >= 3)
     def test_discard_older_messages(self):
         first = self.send(*get_current_url)
         second = self.send(*execute_script)
         resp = self.marionette.client.receive()
         self.assertEqual(second, resp.id)
 
-    @skip_unless_protocol("Skip for level < 3", lambda level: level >= 3)
+    @skip_unless_protocol(lambda level: level >= 3)
     def test_last_id_incremented(self):
         before = self.last_id
         self.send(*get_current_url)
         self.assertGreater(self.last_id, before)
 
 
 class MessageTestCase(MarionetteTestCase):
     def assert_attr(self, obj, attr):
--- a/testing/marionette/harness/marionette_harness/tests/unit/test_typing.py
+++ b/testing/marionette/harness/marionette_harness/tests/unit/test_typing.py
@@ -3,17 +3,17 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 import urllib
 
 from marionette_driver.by import By
 from marionette_driver.errors import ElementNotVisibleException
 from marionette_driver.keys import Keys
 
-from marionette_harness import MarionetteTestCase, skip, skip_if_mobile
+from marionette_harness import MarionetteTestCase, skip_if_mobile
 
 
 def inline(doc):
     return "data:text/html;charset=utf-8,{}".format(urllib.quote(doc))
 
 
 class TypingTestCase(MarionetteTestCase):
 
@@ -27,17 +27,17 @@ class TypingTestCase(MarionetteTestCase)
 
 
 class TestTypingChrome(TypingTestCase):
 
     def setUp(self):
         super(TestTypingChrome, self).setUp()
         self.marionette.set_context("chrome")
 
-    @skip_if_mobile("Interacting with chrome elements not available for Fennec")
+    @skip_if_mobile  # Interacting with chrome elements not available for Fennec
     def test_cut_and_paste_shortcuts(self):
         with self.marionette.using_context("content"):
             test_html = self.marionette.absolute_url("javascriptPage.html")
             self.marionette.navigate(test_html)
 
             keyReporter = self.marionette.find_element(By.ID, "keyReporter")
             self.assertEqual("", keyReporter.get_property("value"))
             keyReporter.send_keys("zyxwvutsr")
@@ -208,17 +208,17 @@ class TestTypingContent(TypingTestCase):
 
         element = self.marionette.find_element(By.ID, "keyPressArea")
         element.send_keys("I like cheese")
         result = self.marionette.find_element(By.ID, "result")
         #  Because the key down gets the result before the input element is
         #  filled, we're a letter short here
         self.assertEqual(result.text, "I like chees")
 
-    @skip_if_mobile("Bug 1324752 - Arrow keys cannot be sent in Fennec")
+    @skip_if_mobile  # Bug 1324752 - Arrow keys cannot be sent in Fennec
     def testShouldReportKeyCodeOfArrowKeysUpDownEvents(self):
         test_html = self.marionette.absolute_url("javascriptPage.html")
         self.marionette.navigate(test_html)
 
         result = self.marionette.find_element(By.ID, "result")
         element = self.marionette.find_element(By.ID, "keyReporter")
 
         element.send_keys(Keys.ARROW_DOWN)
@@ -236,70 +236,74 @@ class TestTypingContent(TypingTestCase):
 
         element.send_keys(Keys.ARROW_RIGHT)
         self.assertIn("down: 39", result.text.strip())
         self.assertIn("up: 39", result.text.strip())
 
         #  And leave no rubbish/printable keys in the "keyReporter"
         self.assertEqual("", element.get_property("value"))
 
-    @skip("Reenable in Bug 1068728")
+    """Disabled. Reenable in Bug 1068728
     def testNumericShiftKeys(self):
         test_html = self.marionette.absolute_url("javascriptPage.html")
         self.marionette.navigate(test_html)
 
         result = self.marionette.find_element(By.ID, "result")
         element = self.marionette.find_element(By.ID, "keyReporter")
         numericShiftsEtc = "~!@#$%^&*()_+{}:i\"<>?|END~"
         element.send_keys(numericShiftsEtc)
         self.assertEqual(numericShiftsEtc, element.get_property("value"))
         self.assertIn(" up: 16", result.text.strip())
+    """
 
     def testLowerCaseAlphaKeys(self):
         test_html = self.marionette.absolute_url("javascriptPage.html")
         self.marionette.navigate(test_html)
 
         element = self.marionette.find_element(By.ID, "keyReporter")
         lowerAlphas = "abcdefghijklmnopqrstuvwxyz"
         element.send_keys(lowerAlphas)
         self.assertEqual(lowerAlphas, element.get_property("value"))
 
-    @skip("Reenable in Bug 1068735")
+    """Disabled. Reenable in Bug 1068735
     def testUppercaseAlphaKeys(self):
         test_html = self.marionette.absolute_url("javascriptPage.html")
         self.marionette.navigate(test_html)
 
         result = self.marionette.find_element(By.ID, "result")
         element = self.marionette.find_element(By.ID, "keyReporter")
         upperAlphas = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
         element.send_keys(upperAlphas)
         self.assertEqual(upperAlphas, element.get_property("value"))
         self.assertIn(" up: 16", result.text.strip())
+    """
 
-    @skip("Reenable in Bug 1068726")
+    """Disabled. Reenable in Bug 1068726
     def testAllPrintableKeys(self):
         test_html = self.marionette.absolute_url("javascriptPage.html")
         self.marionette.navigate(test_html)
 
         result = self.marionette.find_element(By.ID, "result")
         element = self.marionette.find_element(By.ID, "keyReporter")
         allPrintable = "!\"#$%&'()*+,-./0123456789:<=>?@ ABCDEFGHIJKLMNOPQRSTUVWXYZ [\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
         element.send_keys(allPrintable)
 
         self.assertTrue(allPrintable, element.get_property("value"))
         self.assertIn(" up: 16", result.text.strip())
+    """
 
-    @skip("Reenable in Bug 1068733")
+    """Disabled. Reenable in Bug 1068733
     def testSpecialSpaceKeys(self):
         test_html = self.marionette.absolute_url("javascriptPage.html")
         self.marionette.navigate(test_html)
 
         element = self.marionette.find_element(By.ID, "keyReporter")
         element.send_keys("abcd" + Keys.SPACE + "fgh" + Keys.SPACE + "ij")
         self.assertEqual("abcd fgh ij", element.get_property("value"))
+    """
 
     def testShouldTypeAnInteger(self):
         test_html = self.marionette.absolute_url("javascriptPage.html")
         self.marionette.navigate(test_html)
 
         element = self.marionette.find_element(By.ID, "keyReporter")
         element.send_keys(1234)
         self.assertEqual("1234", element.get_property("value"))
--- a/testing/marionette/harness/marionette_harness/tests/unit/unit-tests.ini
+++ b/testing/marionette/harness/marionette_harness/tests/unit/unit-tests.ini
@@ -2,17 +2,16 @@
 [test_geckoinstance.py]
 [test_data_driven.py]
 [test_session.py]
 [test_capabilities.py]
 [test_accessibility.py]
 [test_expectedfail.py]
 expected = fail
 [test_import_script.py]
-[test_certificates.py]
 [test_click.py]
 [test_click_chrome.py]
 skip-if = appname == 'fennec'
 [test_checkbox.py]
 [test_checkbox_chrome.py]
 skip-if = appname == 'fennec'
 [test_elementsize.py]
 [test_elementsize_chrome.py]
--- a/testing/marionette/harness/requirements.txt
+++ b/testing/marionette/harness/requirements.txt
@@ -4,11 +4,11 @@ marionette-driver >= 2.2.0
 mozcrash >= 0.5
 mozdevice >= 0.44
 mozinfo >= 0.8
 mozlog >= 3.0
 moznetwork >= 0.21
 mozprocess >= 0.9
 mozprofile >= 0.7
 mozrunner >= 6.13
-moztest >= 0.8
+moztest >= 0.7
 mozversion >= 1.1
 wptserve >= 1.3.0
--- a/testing/mozbase/moztest/moztest/adapters/unit.py
+++ b/testing/mozbase/moztest/moztest/adapters/unit.py
@@ -129,52 +129,49 @@ class StructuredTestResult(TextTestResul
         self.logger.test_end(test.id(),
                              "ERROR",
                              message=self._extract_err_message(err),
                              expected="PASS",
                              stack=self._extract_stacktrace(err, test),
                              extra=extra)
 
     def addFailure(self, test, err):
-        extra = self.call_callbacks(test, "FAIL")
+        extra = self.call_callbacks(test, "ERROR")
         extra.update(self._get_class_method_name(test))
         self.logger.test_end(test.id(),
                              "FAIL",
                              message=self._extract_err_message(err),
                              expected="PASS",
                              stack=self._extract_stacktrace(err, test),
                              extra=extra)
 
     def addSuccess(self, test):
         extra = self._get_class_method_name(test)
-        self.logger.test_end(test.id(),
-                             "PASS",
-                             expected="PASS",
-                             extra=extra)
+        self.logger.test_end(test.id(), "PASS", expected="PASS", extra=extra)
 
     def addExpectedFailure(self, test, err):
-        extra = self.call_callbacks(test, "FAIL")
+        extra = self.call_callbacks(test, "ERROR")
         extra.update(self._get_class_method_name(test))
         self.logger.test_end(test.id(),
                              "FAIL",
                              message=self._extract_err_message(err),
                              expected="FAIL",
                              stack=self._extract_stacktrace(err, test),
                              extra=extra)
 
     def addUnexpectedSuccess(self, test):
-        extra = self.call_callbacks(test, "PASS")
+        extra = self.call_callbacks(test, "ERROR")
         extra.update(self._get_class_method_name(test))
         self.logger.test_end(test.id(),
                              "PASS",
                              expected="FAIL",
                              extra=extra)
 
     def addSkip(self, test, reason):
-        extra = self.call_callbacks(test, "SKIP")
+        extra = self.call_callbacks(test, "ERROR")
         extra.update(self._get_class_method_name(test))
         self.logger.test_end(test.id(),
                              "SKIP",
                              message=reason,
                              expected="PASS",
                              extra=extra)
 
 
--- a/testing/mozbase/moztest/setup.py
+++ b/testing/mozbase/moztest/setup.py
@@ -1,15 +1,15 @@
 # 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/.
 
 from setuptools import setup, find_packages
 
-PACKAGE_VERSION = '0.8'
+PACKAGE_VERSION = '0.7'
 
 # dependencies
 deps = ['mozinfo']
 
 setup(name='moztest',
       version=PACKAGE_VERSION,
       description="Package for storing and outputting Mozilla test results",
       long_description="see http://mozbase.readthedocs.org/",