Bug 1316851 - Firefox UI tests have to use super() to call base class methods. r=maja_zf
authorHenrik Skupin <mail@hskupin.info>
Fri, 11 Nov 2016 13:38:53 +0100
changeset 322218 cd498d1a4490af65635702ff248cae18a87a4320
parent 322217 e01242f2d83950e6c3ff423a25ebfefc3fa88cec
child 322219 ad8f42a8e7f6948b18c534d811b270ddcea7108c
push id21
push usermaklebus@msu.edu
push dateThu, 01 Dec 2016 06:22:08 +0000
reviewersmaja_zf
bugs1316851
milestone52.0a1
Bug 1316851 - Firefox UI tests have to use super() to call base class methods. r=maja_zf MozReview-Commit-ID: E4FSmQePtqv
testing/firefox-ui/tests/functional/locationbar/test_access_locationbar.py
testing/firefox-ui/tests/functional/locationbar/test_escape_autocomplete.py
testing/firefox-ui/tests/functional/locationbar/test_favicon_in_autocomplete.py
testing/firefox-ui/tests/functional/locationbar/test_suggest_bookmarks.py
testing/firefox-ui/tests/functional/private_browsing/test_about_private_browsing.py
testing/firefox-ui/tests/functional/security/test_dv_certificate.py
testing/firefox-ui/tests/functional/security/test_enable_privilege.py
testing/firefox-ui/tests/functional/security/test_ev_certificate.py
testing/firefox-ui/tests/functional/security/test_mixed_content_page.py
testing/firefox-ui/tests/functional/security/test_mixed_script_content_blocking.py
testing/firefox-ui/tests/functional/security/test_no_certificate.py
testing/firefox-ui/tests/functional/security/test_safe_browsing_initial_download.py
testing/firefox-ui/tests/functional/security/test_safe_browsing_notification.py
testing/firefox-ui/tests/functional/security/test_safe_browsing_warning_pages.py
testing/firefox-ui/tests/functional/security/test_security_notification.py
testing/firefox-ui/tests/functional/security/test_ssl_disabled_error_page.py
testing/firefox-ui/tests/functional/security/test_ssl_status_after_restart.py
testing/firefox-ui/tests/functional/security/test_submit_unencrypted_info_warning.py
testing/firefox-ui/tests/functional/security/test_unknown_issuer.py
testing/firefox-ui/tests/functional/security/test_untrusted_connection_error_page.py
testing/firefox-ui/tests/functional/sessionstore/test_restore_windows_after_restart.py
testing/firefox-ui/tests/puppeteer/test_about_window.py
testing/firefox-ui/tests/puppeteer/test_l10n.py
testing/firefox-ui/tests/puppeteer/test_menubar.py
testing/firefox-ui/tests/puppeteer/test_notifications.py
testing/firefox-ui/tests/puppeteer/test_page_info_window.py
testing/firefox-ui/tests/puppeteer/test_places.py
testing/firefox-ui/tests/puppeteer/test_prefs.py
testing/firefox-ui/tests/puppeteer/test_software_update.py
testing/firefox-ui/tests/puppeteer/test_tabbar.py
testing/firefox-ui/tests/puppeteer/test_toolbars.py
testing/firefox-ui/tests/puppeteer/test_update_wizard.py
testing/firefox-ui/tests/puppeteer/test_utils.py
testing/firefox-ui/tests/puppeteer/test_windows.py
--- a/testing/firefox-ui/tests/functional/locationbar/test_access_locationbar.py
+++ b/testing/firefox-ui/tests/functional/locationbar/test_access_locationbar.py
@@ -5,17 +5,17 @@
 from marionette_driver import Wait
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestAccessLocationBar(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestAccessLocationBar, self).setUp()
 
         # Clear complete history so there's no interference from previous entries.
         self.puppeteer.places.remove_all_history()
 
         self.test_urls = [
             'layout/mozilla_projects.html',
             'layout/mozilla.html',
             'layout/mozilla_mission.html'
--- a/testing/firefox-ui/tests/functional/locationbar/test_escape_autocomplete.py
+++ b/testing/firefox-ui/tests/functional/locationbar/test_escape_autocomplete.py
@@ -5,17 +5,17 @@
 from marionette_driver import Wait
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestEscapeAutocomplete(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestEscapeAutocomplete, self).setUp()
 
         # Clear complete history so there's no interference from previous entries.
         self.puppeteer.places.remove_all_history()
 
         self.test_urls = [
             'layout/mozilla.html',
             'layout/mozilla_community.html',
         ]
@@ -24,17 +24,18 @@ class TestEscapeAutocomplete(FirefoxTest
 
         self.test_string = 'mozilla'
 
         self.locationbar = self.browser.navbar.locationbar
         self.autocomplete_results = self.locationbar.autocomplete_results
 
     def tearDown(self):
         self.autocomplete_results.close(force=True)
-        FirefoxTestCase.tearDown(self)
+
+        super(TestEscapeAutocomplete, self).tearDown()
 
     def test_escape_autocomplete(self):
         # Open some local pages
         def load_urls():
             with self.marionette.using_context('content'):
                 for url in self.test_urls:
                     self.marionette.navigate(url)
         self.puppeteer.places.wait_for_visited(self.test_urls, load_urls)
--- a/testing/firefox-ui/tests/functional/locationbar/test_favicon_in_autocomplete.py
+++ b/testing/firefox-ui/tests/functional/locationbar/test_favicon_in_autocomplete.py
@@ -8,17 +8,17 @@ from firefox_ui_harness.testcases import
 
 
 class TestFaviconInAutocomplete(FirefoxTestCase):
 
     PREF_SUGGEST_SEARCHES = 'browser.urlbar.suggest.searches'
     PREF_SUGGEST_BOOKMARK = 'browser.urlbar.suggest.bookmark'
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestFaviconInAutocomplete, self).setUp()
 
         # Disable suggestions for searches and bookmarks to get results only for history
         self.puppeteer.prefs.set_pref(self.PREF_SUGGEST_SEARCHES, False)
         self.puppeteer.prefs.set_pref(self.PREF_SUGGEST_BOOKMARK, False)
 
         self.puppeteer.places.remove_all_history()
 
         self.test_urls = [self.marionette.absolute_url('layout/mozilla.html')]
@@ -29,17 +29,17 @@ class TestFaviconInAutocomplete(FirefoxT
         self.autocomplete_results = self.browser.navbar.locationbar.autocomplete_results
 
     def tearDown(self):
         try:
             self.autocomplete_results.close(force=True)
             self.marionette.clear_pref(self.PREF_SUGGEST_SEARCHES)
             self.marionette.clear_pref(self.PREF_SUGGEST_BOOKMARK)
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestFaviconInAutocomplete, self).tearDown()
 
     def test_favicon_in_autocomplete(self):
         # Open the test page
         def load_urls():
             with self.marionette.using_context('content'):
                 self.marionette.navigate(self.test_urls[0])
         self.puppeteer.places.wait_for_visited(self.test_urls, load_urls)
 
--- a/testing/firefox-ui/tests/functional/locationbar/test_suggest_bookmarks.py
+++ b/testing/firefox-ui/tests/functional/locationbar/test_suggest_bookmarks.py
@@ -11,17 +11,17 @@ class TestStarInAutocomplete(FirefoxTest
     """ This replaces
     http://hg.mozilla.org/qa/mozmill-tests/file/default/firefox/tests/functional/testAwesomeBar/testSuggestBookmarks.js
     Check a star appears in autocomplete list for a bookmarked page.
     """
 
     PREF_SUGGEST_SEARCHES = 'browser.urlbar.suggest.searches'
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestStarInAutocomplete, self).setUp()
 
         self.bookmark_panel = None
         self.test_urls = [self.marionette.absolute_url('layout/mozilla_grants.html')]
 
         # Disable search suggestions to only get results for history and bookmarks
         self.puppeteer.prefs.set_pref(self.PREF_SUGGEST_SEARCHES, False)
 
         with self.marionette.using_context('content'):
@@ -36,17 +36,17 @@ class TestStarInAutocomplete(FirefoxTest
                 self.marionette.execute_script("""
                   arguments[0].hidePopup();
                 """, script_args=[self.bookmark_panel])
 
             self.browser.navbar.locationbar.autocomplete_results.close()
             self.puppeteer.places.restore_default_bookmarks()
             self.marionette.clear_pref(self.PREF_SUGGEST_SEARCHES)
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestStarInAutocomplete, self).tearDown()
 
     def test_star_in_autocomplete(self):
         search_string = 'grants'
 
         def visit_urls():
             with self.marionette.using_context('content'):
                 for url in self.test_urls:
                     self.marionette.navigate(url)
--- a/testing/firefox-ui/tests/functional/private_browsing/test_about_private_browsing.py
+++ b/testing/firefox-ui/tests/functional/private_browsing/test_about_private_browsing.py
@@ -7,29 +7,29 @@ from marionette_driver import By, Wait
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 from firefox_puppeteer.ui.browser.window import BrowserWindow
 
 
 class TestAboutPrivateBrowsing(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestAboutPrivateBrowsing, self).setUp()
 
         # Use a fake local support URL
         support_url = 'about:blank?'
         self.puppeteer.prefs.set_pref('app.support.baseURL', support_url)
 
         self.pb_url = support_url + 'private-browsing'
 
     def tearDown(self):
         try:
             self.marionette.clear_pref('app.support.baseURL')
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestAboutPrivateBrowsing, self).tearDown()
 
     def testCheckAboutPrivateBrowsing(self):
         self.assertFalse(self.browser.is_private)
 
         with self.marionette.using_context('content'):
             self.marionette.navigate('about:privatebrowsing')
 
             status_node = self.marionette.find_element(By.CSS_SELECTOR, 'p.showNormal')
--- a/testing/firefox-ui/tests/functional/security/test_dv_certificate.py
+++ b/testing/firefox-ui/tests/functional/security/test_dv_certificate.py
@@ -5,30 +5,30 @@
 from marionette_driver import Wait
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestDVCertificate(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestDVCertificate, self).setUp()
 
         self.locationbar = self.browser.navbar.locationbar
         self.identity_popup = self.browser.navbar.locationbar.identity_popup
 
         self.url = 'https://ssl-dv.mozqa.com'
 
     def tearDown(self):
         try:
             self.browser.switch_to()
             self.identity_popup.close(force=True)
             self.puppeteer.windows.close_all([self.browser])
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestDVCertificate, self).tearDown()
 
     def test_dv_cert(self):
         with self.marionette.using_context('content'):
             self.marionette.navigate(self.url)
 
         # The lock icon should be shown
         self.assertIn('identity-secure',
                       self.locationbar.connection_icon.value_of_css_property('list-style-image'))
--- a/testing/firefox-ui/tests/functional/security/test_enable_privilege.py
+++ b/testing/firefox-ui/tests/functional/security/test_enable_privilege.py
@@ -4,19 +4,15 @@
 
 from marionette_driver import By
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestEnablePrivilege(FirefoxTestCase):
 
-    def setUp(self):
-        FirefoxTestCase.setUp(self)
-
-        self.url = self.marionette.absolute_url('security/enable_privilege.html')
-
     def test_enable_privilege(self):
         with self.marionette.using_context('content'):
-            self.marionette.navigate(self.url)
+            url = self.marionette.absolute_url('security/enable_privilege.html')
+            self.marionette.navigate(url)
 
             result = self.marionette.find_element(By.ID, 'result')
             self.assertEqual(result.get_property('textContent'), 'PASS')
--- a/testing/firefox-ui/tests/functional/security/test_ev_certificate.py
+++ b/testing/firefox-ui/tests/functional/security/test_ev_certificate.py
@@ -5,30 +5,30 @@
 from marionette_driver import Wait
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestEVCertificate(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestEVCertificate, self).setUp()
 
         self.locationbar = self.browser.navbar.locationbar
         self.identity_popup = self.locationbar.identity_popup
 
         self.url = 'https://ssl-ev.mozqa.com/'
 
     def tearDown(self):
         try:
             self.browser.switch_to()
             self.identity_popup.close(force=True)
             self.puppeteer.windows.close_all([self.browser])
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestEVCertificate, self).tearDown()
 
     def test_ev_certificate(self):
         with self.marionette.using_context('content'):
             self.marionette.navigate(self.url)
 
         # The lock icon should be shown
         self.assertIn('identity-secure',
                       self.locationbar.connection_icon.value_of_css_property('list-style-image'))
--- a/testing/firefox-ui/tests/functional/security/test_mixed_content_page.py
+++ b/testing/firefox-ui/tests/functional/security/test_mixed_content_page.py
@@ -2,28 +2,28 @@
 # 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 firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestMixedContentPage(FirefoxTestCase):
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestMixedContentPage, self).setUp()
 
         self.locationbar = self.browser.navbar.locationbar
         self.identity_popup = self.locationbar.identity_popup
 
         self.url = 'https://mozqa.com/data/firefox/security/mixedcontent.html'
 
     def tearDown(self):
         try:
             self.identity_popup.close(force=True)
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestMixedContentPage, self).tearDown()
 
     def test_mixed_content(self):
         with self.marionette.using_context('content'):
             self.marionette.navigate(self.url)
 
         self.assertIn('identity-mixed-passive-loaded',
                       self.locationbar.connection_icon.value_of_css_property('list-style-image'))
 
--- a/testing/firefox-ui/tests/functional/security/test_mixed_script_content_blocking.py
+++ b/testing/firefox-ui/tests/functional/security/test_mixed_script_content_blocking.py
@@ -5,17 +5,17 @@
 from marionette_driver import By, Wait
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestMixedScriptContentBlocking(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestMixedScriptContentBlocking, self).setUp()
 
         self.url = 'https://mozqa.com/data/firefox/security/mixed_content_blocked/index.html'
 
         self.test_elements = [
             ('result1', 'Insecure script one'),
             ('result2', 'Insecure script from iFrame'),
             ('result3', 'Insecure plugin'),
             ('result4', 'Insecure stylesheet'),
@@ -23,17 +23,17 @@ class TestMixedScriptContentBlocking(Fir
 
         self.locationbar = self.browser.navbar.locationbar
         self.identity_popup = self.locationbar.identity_popup
 
     def tearDown(self):
         try:
             self.identity_popup.close(force=True)
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestMixedScriptContentBlocking, self).tearDown()
 
     def _expect_protection_status(self, enabled):
         if enabled:
             color, icon_filename, state = (
                 'rgb(0, 136, 0)',
                 'identity-secure',
                 'blocked'
             )
--- a/testing/firefox-ui/tests/functional/security/test_no_certificate.py
+++ b/testing/firefox-ui/tests/functional/security/test_no_certificate.py
@@ -7,30 +7,30 @@ from urlparse import urlparse
 from marionette_driver import expected, Wait
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestNoCertificate(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestNoCertificate, self).setUp()
 
         self.locationbar = self.browser.navbar.locationbar
         self.identity_popup = self.locationbar.identity_popup
 
         self.url = self.marionette.absolute_url('layout/mozilla.html')
 
     def tearDown(self):
         try:
             self.browser.switch_to()
             self.identity_popup.close(force=True)
             self.puppeteer.windows.close_all([self.browser])
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestNoCertificate, self).tearDown()
 
     def test_no_certificate(self):
         with self.marionette.using_context('content'):
             self.marionette.navigate(self.url)
 
         # Check the favicon
         # TODO: find a better way to check, e.g., mozmill's isDisplayed
         favicon_hidden = self.marionette.execute_script("""
--- a/testing/firefox-ui/tests/functional/security/test_safe_browsing_initial_download.py
+++ b/testing/firefox-ui/tests/functional/security/test_safe_browsing_initial_download.py
@@ -46,33 +46,33 @@ class TestSafeBrowsingInitialDownload(Fi
         for pref_name in self.prefs_download_lists:
             base_names = self.marionette.get_pref(pref_name).split(',')
             for ext in self.file_extensions:
                 files.extend(['{file}.{ext}'.format(file=f, ext=ext) for f in base_names if f])
 
         return set(sorted(files))
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestSafeBrowsingInitialDownload, self).setUp()
 
         # Force the preferences for the new profile
         enforce_prefs = self.prefs_safebrowsing
         enforce_prefs.update(self.prefs_provider_update_time)
         self.marionette.enforce_gecko_prefs(enforce_prefs)
 
         self.safebrowsing_path = os.path.join(self.marionette.instance.profile.profile,
                                               'safebrowsing')
         self.safebrowsing_files = self.get_safebrowsing_files()
 
     def tearDown(self):
         try:
             # Restart with a fresh profile
             self.restart(clean=True)
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestSafeBrowsingInitialDownload, self).tearDown()
 
     def test_safe_browsing_initial_download(self):
         def check_downloaded(_):
             return reduce(lambda state, pref: state and int(self.marionette.get_pref(pref)) != 1,
                           self.prefs_provider_update_time.keys(), True)
 
         try:
             Wait(self.marionette, timeout=60).until(
--- a/testing/firefox-ui/tests/functional/security/test_safe_browsing_notification.py
+++ b/testing/firefox-ui/tests/functional/security/test_safe_browsing_notification.py
@@ -7,17 +7,17 @@ import time
 from marionette_driver import By, expected, Wait
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestSafeBrowsingNotificationBar(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestSafeBrowsingNotificationBar, self).setUp()
 
         self.test_data = [
             # Unwanted software URL
             {
                 # First two properties are not needed,
                 # since these errors are not reported
                 'button_property': None,
                 'report_page': None,
@@ -51,17 +51,17 @@ class TestSafeBrowsingNotificationBar(Fi
 
     def tearDown(self):
         try:
             self.puppeteer.utils.permissions.remove('https://www.itisatrap.org', 'safe-browsing')
             self.browser.tabbar.close_all_tabs([self.browser.tabbar.tabs[0]])
             self.marionette.clear_pref('browser.safebrowsing.phishing.enabled')
             self.marionette.clear_pref('browser.safebrowsing.malware.enabled')
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestSafeBrowsingNotificationBar, self).tearDown()
 
     def test_notification_bar(self):
         with self.marionette.using_context('content'):
             for item in self.test_data:
                 button_property = item['button_property']
                 report_page, unsafe_page = item['report_page'], item['unsafe_page']
 
                 # Navigate to the unsafe page
--- a/testing/firefox-ui/tests/functional/security/test_safe_browsing_warning_pages.py
+++ b/testing/firefox-ui/tests/functional/security/test_safe_browsing_warning_pages.py
@@ -7,17 +7,17 @@ import time
 from marionette_driver import By, expected, Wait
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestSafeBrowsingWarningPages(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestSafeBrowsingWarningPages, self).setUp()
 
         self.urls = [
             # Unwanted software URL
             'https://www.itisatrap.org/firefox/unwanted.html',
             # Phishing URL
             'https://www.itisatrap.org/firefox/its-a-trap.html',
             # Malware URL
             'https://www.itisatrap.org/firefox/its-an-attack.html'
@@ -37,17 +37,17 @@ class TestSafeBrowsingWarningPages(Firef
 
     def tearDown(self):
         try:
             self.puppeteer.utils.permissions.remove('https://www.itisatrap.org', 'safe-browsing')
             self.browser.tabbar.close_all_tabs([self.browser.tabbar.tabs[0]])
             self.marionette.clear_pref('browser.safebrowsing.malware.enabled')
             self.marionette.clear_pref('browser.safebrowsing.phishing.enabled')
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestSafeBrowsingWarningPages, self).tearDown()
 
     def test_warning_pages(self):
         with self.marionette.using_context("content"):
             for unsafe_page in self.urls:
                 # Load a test page, then test the get me out button
                 self.marionette.navigate(unsafe_page)
                 # Wait for the DOM to receive events for about:blocked
                 time.sleep(1)
--- a/testing/firefox-ui/tests/functional/security/test_security_notification.py
+++ b/testing/firefox-ui/tests/functional/security/test_security_notification.py
@@ -8,17 +8,17 @@ from marionette_driver import By, Wait
 from marionette_driver.errors import MarionetteException
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestSecurityNotification(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestSecurityNotification, self).setUp()
 
         self.urls = [
             # Invalid cert page
             'https://ssl-expired.mozqa.com',
             # Secure page
             'https://ssl-ev.mozqa.com/',
             # Insecure page
             'http://www.mozqa.com'
--- a/testing/firefox-ui/tests/functional/security/test_ssl_disabled_error_page.py
+++ b/testing/firefox-ui/tests/functional/security/test_ssl_disabled_error_page.py
@@ -8,34 +8,34 @@ from marionette_driver import By, expect
 from marionette_driver.errors import MarionetteException
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestSSLDisabledErrorPage(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestSSLDisabledErrorPage, self).setUp()
 
         self.url = 'https://tlsv1-0.mozqa.com'
 
         self.puppeteer.utils.sanitize({"sessions": True})
 
         # Disable SSL 3.0, TLS 1.0 and TLS 1.1 for secure connections
         # by forcing the use of TLS 1.2
         # see: http://kb.mozillazine.org/Security.tls.version.*#Possible_values_and_their_effects
         self.puppeteer.prefs.set_pref('security.tls.version.min', 3)
         self.puppeteer.prefs.set_pref('security.tls.version.max', 3)
 
     def tearDown(self):
         try:
             self.marionette.clear_pref('security.tls.version.min')
             self.marionette.clear_pref('security.tls.version.max')
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestSSLDisabledErrorPage, self).tearDown()
 
     def test_ssl_disabled_error_page(self):
         with self.marionette.using_context('content'):
             # Open the test page
             self.assertRaises(MarionetteException, self.marionette.navigate, self.url)
 
             # Wait for the DOM to receive events
             time.sleep(1)
--- 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
@@ -6,17 +6,17 @@ from marionette_driver import Wait
 from marionette.marionette_test import skip_if_e10s
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestSSLStatusAfterRestart(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestSSLStatusAfterRestart, self).setUp()
 
         self.test_data = (
             {
                 'url': 'https://ssl-dv.mozqa.com',
                 'identity': '',
                 'type': 'secure'
             },
             {
@@ -40,17 +40,17 @@ class TestSSLStatusAfterRestart(FirefoxT
     def tearDown(self):
         try:
             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:
-            FirefoxTestCase.tearDown(self)
+            super(TestSSLStatusAfterRestart, self).tearDown()
 
     @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()
--- a/testing/firefox-ui/tests/functional/security/test_submit_unencrypted_info_warning.py
+++ b/testing/firefox-ui/tests/functional/security/test_submit_unencrypted_info_warning.py
@@ -8,28 +8,28 @@ from marionette_driver.errors import NoA
 from marionette_driver.marionette import Alert
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestSubmitUnencryptedInfoWarning(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestSubmitUnencryptedInfoWarning, self).setUp()
 
         self.url = 'https://ssl-dv.mozqa.com/data/firefox/security/unencryptedsearch.html'
         self.test_string = 'mozilla'
 
         self.puppeteer.prefs.set_pref('security.warn_submit_insecure', True)
 
     def tearDown(self):
         try:
             self.marionette.clear_pref('security.warn_submit_insecure')
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestSubmitUnencryptedInfoWarning, self).tearDown()
 
     def test_submit_unencrypted_info_warning(self):
         with self.marionette.using_context('content'):
             self.marionette.navigate(self.url)
 
             # Get the page's search box and submit button.
             searchbox = self.marionette.find_element(By.ID, 'q')
             button = self.marionette.find_element(By.ID, 'submit')
--- a/testing/firefox-ui/tests/functional/security/test_unknown_issuer.py
+++ b/testing/firefox-ui/tests/functional/security/test_unknown_issuer.py
@@ -8,17 +8,17 @@ from marionette_driver import By
 from marionette_driver.errors import MarionetteException
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestUnknownIssuer(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestUnknownIssuer, self).setUp()
 
         self.url = 'https://ssl-unknownissuer.mozqa.com'
 
     def test_unknown_issuer(self):
         with self.marionette.using_context('content'):
             # Go to a site that has a cert with an unknown issuer
             self.assertRaises(MarionetteException, self.marionette.navigate, self.url)
 
--- a/testing/firefox-ui/tests/functional/security/test_untrusted_connection_error_page.py
+++ b/testing/firefox-ui/tests/functional/security/test_untrusted_connection_error_page.py
@@ -6,18 +6,19 @@ import time
 
 from marionette_driver import By, Wait
 from marionette_driver.errors import MarionetteException
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestUntrustedConnectionErrorPage(FirefoxTestCase):
+
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestUntrustedConnectionErrorPage, self).setUp()
 
         self.url = 'https://ssl-selfsigned.mozqa.com'
 
     def test_untrusted_connection_error_page(self):
         self.marionette.set_context('content')
 
         # In some localized builds, the default page redirects
         target_url = self.browser.get_final_url(self.browser.default_homepage)
--- a/testing/firefox-ui/tests/functional/sessionstore/test_restore_windows_after_restart.py
+++ b/testing/firefox-ui/tests/functional/sessionstore/test_restore_windows_after_restart.py
@@ -3,17 +3,17 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestRestoreWindowsAfterRestart(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestRestoreWindowsAfterRestart, self).setUp()
 
         # Each list element represents a window of tabs loaded at
         # some testing URL
         self.test_windows = set([
             # Window 1. Note the comma after the absolute_url call -
             # this is Python's way of declaring a 1 item tuple.
             (self.marionette.absolute_url('layout/mozilla.html'), ),
 
@@ -46,17 +46,17 @@ class TestRestoreWindowsAfterRestart(Fir
             'browser.sessionstore.debug.no_auto_updates': True,
         })
 
     def tearDown(self):
         try:
             # Create a fresh profile for subsequent tests.
             self.restart(clean=True)
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestRestoreWindowsAfterRestart, self).tearDown()
 
     def test_with_variety(self):
         """ Opens a set of windows, both standard and private, with
         some number of tabs in them. Once the tabs have loaded, restarts
         the browser, and then ensures that the standard tabs have been
         restored, and that the private ones have not.
         """
         self.open_windows(self.test_windows)
--- a/testing/firefox-ui/tests/puppeteer/test_about_window.py
+++ b/testing/firefox-ui/tests/puppeteer/test_about_window.py
@@ -3,26 +3,26 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestAboutWindow(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestAboutWindow, self).setUp()
 
         self.about_window = self.browser.open_about_window()
         self.deck = self.about_window.deck
 
     def tearDown(self):
         try:
             self.puppeteer.windows.close_all([self.browser])
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestAboutWindow, self).tearDown()
 
     def test_basic(self):
         self.assertEqual(self.about_window.window_type, 'Browser:About')
 
     def test_elements(self):
         """Test correct retrieval of elements."""
         self.assertNotEqual(self.about_window.dtds, [])
 
--- a/testing/firefox-ui/tests/puppeteer/test_l10n.py
+++ b/testing/firefox-ui/tests/puppeteer/test_l10n.py
@@ -7,21 +7,19 @@ from marionette_driver.errors import Mar
 
 from firefox_puppeteer.api.l10n import L10n
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestL10n(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
-        self.l10n = L10n(self.marionette)
+        super(TestL10n, self).setUp()
 
-    def tearDown(self):
-        FirefoxTestCase.tearDown(self)
+        self.l10n = L10n(self.marionette)
 
     def test_dtd_entity_chrome(self):
         dtds = ['chrome://global/locale/about.dtd',
                 'chrome://browser/locale/baseMenuOverlay.dtd']
 
         value = self.l10n.get_entity(dtds, 'helpSafeMode.label')
         elm = self.marionette.find_element(By.ID, 'helpSafeMode')
         self.assertEqual(value, elm.get_attribute('label'))
--- a/testing/firefox-ui/tests/puppeteer/test_menubar.py
+++ b/testing/firefox-ui/tests/puppeteer/test_menubar.py
@@ -5,17 +5,17 @@
 from marionette_driver.errors import NoSuchElementException
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestMenuBar(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestMenuBar, self).setUp()
 
     def test_click_item_in_menubar(self):
         def opener(_):
             self.browser.menubar.select_by_id('file-menu',
                                               'menu_newNavigatorTab')
 
         self.browser.tabbar.open_tab(trigger=opener)
 
--- a/testing/firefox-ui/tests/puppeteer/test_notifications.py
+++ b/testing/firefox-ui/tests/puppeteer/test_notifications.py
@@ -10,34 +10,34 @@ from firefox_puppeteer.ui.browser.notifi
     AddOnInstallFailedNotification,
     AddOnInstallConfirmationNotification
 )
 
 
 class TestNotifications(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestNotifications, self).setUp()
 
         self.puppeteer.prefs.set_pref('extensions.install.requireSecureOrigin', False)
 
         self.addons_url = self.marionette.absolute_url('addons/extensions/')
         self.puppeteer.utils.permissions.add(self.marionette.baseurl, 'install')
 
     def tearDown(self):
         try:
             self.marionette.clear_pref('extensions.install.requireSecureOrigin')
             self.marionette.clear_pref('xpinstall.signatures.required')
 
             self.puppeteer.utils.permissions.remove(self.addons_url, 'install')
 
             if self.browser.notification:
                 self.browser.notification.close(force=True)
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestNotifications, self).tearDown()
 
     def test_open_close_notification(self):
         """Trigger and dismiss a notification"""
         self.assertIsNone(self.browser.notification)
         self.trigger_addon_notification('restartless_addon_signed.xpi')
         self.browser.notification.close()
         self.assertIsNone(self.browser.notification)
 
--- a/testing/firefox-ui/tests/puppeteer/test_page_info_window.py
+++ b/testing/firefox-ui/tests/puppeteer/test_page_info_window.py
@@ -6,17 +6,17 @@ from firefox_ui_harness.testcases import
 
 
 class TestPageInfoWindow(FirefoxTestCase):
 
     def tearDown(self):
         try:
             self.puppeteer.windows.close_all([self.browser])
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestPageInfoWindow, self).tearDown()
 
     def test_elements(self):
         """Test correct retrieval of elements."""
         page_info = self.browser.open_page_info_window()
 
         self.assertNotEqual(page_info.dtds, [])
         self.assertNotEqual(page_info.properties, [])
 
--- a/testing/firefox-ui/tests/puppeteer/test_places.py
+++ b/testing/firefox-ui/tests/puppeteer/test_places.py
@@ -5,28 +5,28 @@
 from marionette_driver import By, Wait
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestPlaces(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestPlaces, self).setUp()
 
         self.urls = [self.marionette.absolute_url('layout/mozilla_governance.html'),
                      self.marionette.absolute_url('layout/mozilla_grants.html'),
                      ]
 
     def tearDown(self):
         try:
             self.puppeteer.places.restore_default_bookmarks()
             self.puppeteer.places.remove_all_history()
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestPlaces, self).tearDown()
 
     def get_all_urls_in_history(self):
         return self.marionette.execute_script("""
           let hs = Components.classes["@mozilla.org/browser/nav-history-service;1"]
                    .getService(Components.interfaces.nsINavHistoryService);
           let urls = [];
 
           let options = hs.getNewQueryOptions();
--- a/testing/firefox-ui/tests/puppeteer/test_prefs.py
+++ b/testing/firefox-ui/tests/puppeteer/test_prefs.py
@@ -3,17 +3,17 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class testPreferences(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(testPreferences, self).setUp()
 
         self.new_pref = 'marionette.unittest.set_pref'
         self.unknown_pref = 'marionette.unittest.unknown'
 
         self.bool_pref = 'browser.tabs.loadBookmarksInBackground'
         self.int_pref = 'browser.tabs.maxOpenBeforeWarn'
         # Consider using new test preferences
         # See Bug 1303863 Comment #32
@@ -22,17 +22,17 @@ class testPreferences(FirefoxTestCase):
     def tearDown(self):
         try:
             self.marionette.clear_pref('marionette.unittest.set_pref')
             self.marionette.clear_pref('marionette.unittest.unknown')
             self.marionette.clear_pref('browser.tabs.loadBookmarksInBackground')
             self.marionette.clear_pref('browser.tabs.maxOpenBeforeWarn')
             self.marionette.clear_pref('browser.startup.homepage')
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(testPreferences, self).tearDown()
 
     def test_get_pref(self):
         # check correct types
         self.assertTrue(isinstance(self.puppeteer.prefs.get_pref(self.bool_pref),
                                    bool))
         self.assertTrue(isinstance(self.puppeteer.prefs.get_pref(self.int_pref),
                                    int))
         self.assertTrue(isinstance(self.puppeteer.prefs.get_pref(self.string_pref),
--- a/testing/firefox-ui/tests/puppeteer/test_software_update.py
+++ b/testing/firefox-ui/tests/puppeteer/test_software_update.py
@@ -7,27 +7,28 @@ import os
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 from firefox_puppeteer.api.software_update import SoftwareUpdate
 
 
 class TestSoftwareUpdate(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestSoftwareUpdate, self).setUp()
+
         self.software_update = SoftwareUpdate(self.marionette)
 
         self.saved_mar_channels = self.software_update.mar_channels.channels
         self.software_update.mar_channels.channels = set(['expected', 'channels'])
 
     def tearDown(self):
         try:
             self.software_update.mar_channels.channels = self.saved_mar_channels
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestSoftwareUpdate, self).tearDown()
 
     def test_abi(self):
         self.assertTrue(self.software_update.ABI)
 
     def test_allowed(self):
         self.assertTrue(self.software_update.allowed)
 
     def test_build_info(self):
@@ -66,53 +67,55 @@ class TestSoftwareUpdate(FirefoxTestCase
 
     def test_staging_directory(self):
         self.assertTrue(self.software_update.staging_directory)
 
 
 class TestUpdateChannel(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestUpdateChannel, self).setUp()
+
         self.software_update = SoftwareUpdate(self.marionette)
 
         self.saved_channel = self.software_update.update_channel.default_channel
         self.software_update.update_channel.default_channel = 'expected_channel'
 
     def tearDown(self):
         try:
             self.software_update.update_channel.default_channel = self.saved_channel
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestUpdateChannel, self).tearDown()
 
     def test_update_channel_channel(self):
         self.assertEqual(self.software_update.update_channel.channel, self.saved_channel)
 
     def test_update_channel_default_channel(self):
         self.assertEqual(self.software_update.update_channel.default_channel, 'expected_channel')
 
     def test_update_channel_set_default_channel(self):
         self.software_update.update_channel.default_channel = 'new_channel'
         self.assertEqual(self.software_update.update_channel.default_channel, 'new_channel')
 
 
 class TestMARChannels(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestMARChannels, self).setUp()
+
         self.software_update = SoftwareUpdate(self.marionette)
 
         self.saved_mar_channels = self.software_update.mar_channels.channels
         self.software_update.mar_channels.channels = set(['expected', 'channels'])
 
     def tearDown(self):
         try:
             self.software_update.mar_channels.channels = self.saved_mar_channels
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestMARChannels, self).tearDown()
 
     def test_mar_channels_channels(self):
         self.assertEqual(self.software_update.mar_channels.channels, set(['expected', 'channels']))
 
     def test_mar_channels_set_channels(self):
         self.software_update.mar_channels.channels = set(['a', 'b', 'c'])
         self.assertEqual(self.software_update.mar_channels.channels, set(['a', 'b', 'c']))
 
--- a/testing/firefox-ui/tests/puppeteer/test_tabbar.py
+++ b/testing/firefox-ui/tests/puppeteer/test_tabbar.py
@@ -8,17 +8,17 @@ from firefox_puppeteer.errors import NoC
 
 
 class TestTabBar(FirefoxTestCase):
 
     def tearDown(self):
         try:
             self.browser.tabbar.close_all_tabs([self.browser.tabbar.tabs[0]])
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestTabBar, self).tearDown()
 
     def test_basics(self):
         tabbar = self.browser.tabbar
 
         self.assertEqual(tabbar.window, self.browser)
 
         self.assertEqual(len(tabbar.tabs), 1)
         self.assertEqual(tabbar.tabs[0].handle, self.marionette.current_window_handle)
@@ -115,17 +115,17 @@ class TestTabBar(FirefoxTestCase):
 
 
 class TestTab(FirefoxTestCase):
 
     def tearDown(self):
         try:
             self.browser.tabbar.close_all_tabs([self.browser.tabbar.tabs[0]])
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestTab, self).tearDown()
 
     def test_basic(self):
         tab = self.browser.tabbar.tabs[0]
 
         self.assertEqual(tab.window, self.browser)
 
         self.assertEqual(tab.tab_element.get_attribute('localName'), 'tab')
         self.assertEqual(tab.close_button.get_attribute('localName'), 'toolbarbutton')
--- a/testing/firefox-ui/tests/puppeteer/test_toolbars.py
+++ b/testing/firefox-ui/tests/puppeteer/test_toolbars.py
@@ -6,17 +6,17 @@ from marionette_driver import expected, 
 from marionette_driver.errors import NoSuchElementException
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestNavBar(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestNavBar, self).setUp()
 
         self.navbar = self.browser.navbar
         self.url = self.marionette.absolute_url('layout/mozilla.html')
 
         with self.marionette.using_context('content'):
             self.marionette.navigate('about:blank')
 
         # TODO: check why self.puppeteer.places.remove_all_history() does not work here
@@ -75,17 +75,17 @@ class TestNavBar(FirefoxTestCase):
         Wait(self.marionette).until(expected.element_not_present(lambda m:
                                     m.find_element(By.ID, 'mozilla_logo')))
         self.assertEqual(self.marionette.get_url(), self.browser.default_homepage)
 
 
 class TestLocationBar(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestLocationBar, self).setUp()
 
         self.locationbar = self.browser.navbar.locationbar
 
     def test_elements(self):
         self.assertEqual(self.locationbar.urlbar.get_attribute('localName'), 'textbox')
         self.assertIn('urlbar-input', self.locationbar.urlbar_input.get_attribute('className'))
 
         self.assertEqual(self.locationbar.connection_icon.get_attribute('localName'), 'image')
@@ -131,30 +131,31 @@ class TestLocationBar(FirefoxTestCase):
 
         with self.marionette.using_context('content'):
             Wait(self.marionette).until(lambda mn: mn.get_url() == data_uri)
 
 
 class TestAutoCompleteResults(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestAutoCompleteResults, self).setUp()
+
         self.browser.navbar.locationbar.clear()
 
         self.autocomplete_results = self.browser.navbar.locationbar.autocomplete_results
 
     def tearDown(self):
         try:
             self.autocomplete_results.close(force=True)
         except NoSuchElementException:
             # TODO: A NoSuchElementException is thrown here when tests accessing the
             # autocomplete_results element are skipped.
             pass
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestAutoCompleteResults, self).tearDown()
 
     def test_popup_elements(self):
         # TODO: This test is not very robust because it relies on the history
         # in the default profile.
         self.assertFalse(self.autocomplete_results.is_open)
         self.browser.navbar.locationbar.urlbar.send_keys('a')
         results = self.autocomplete_results.results
         Wait(self.marionette).until(lambda _: self.autocomplete_results.is_complete)
@@ -199,31 +200,31 @@ class TestAutoCompleteResults(FirefoxTes
                 for match_fragment in all_matches:
                     self.assertIn(match_fragment.lower(), input_text)
 
             self.autocomplete_results.close()
 
 
 class TestIdentityPopup(FirefoxTestCase):
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestIdentityPopup, self).setUp()
 
         self.locationbar = self.browser.navbar.locationbar
         self.identity_popup = self.locationbar.identity_popup
 
         self.url = 'https://ssl-ev.mozqa.com'
 
         with self.marionette.using_context('content'):
             self.marionette.navigate(self.url)
 
     def tearDown(self):
         try:
             self.identity_popup.close(force=True)
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestIdentityPopup, self).tearDown()
 
     def test_elements(self):
         self.locationbar.open_identity_popup()
 
         # Test main view elements
         main = self.identity_popup.view.main
         self.assertEqual(main.element.get_attribute('localName'), 'panelview')
 
--- a/testing/firefox-ui/tests/puppeteer/test_update_wizard.py
+++ b/testing/firefox-ui/tests/puppeteer/test_update_wizard.py
@@ -4,34 +4,34 @@
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 from firefox_puppeteer.ui.update_wizard import UpdateWizardDialog
 
 
 class TestUpdateWizard(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestUpdateWizard, self).setUp()
 
         def opener(win):
             self.marionette.execute_script("""
               let updatePrompt = Components.classes["@mozilla.org/updates/update-prompt;1"]
                                  .createInstance(Components.interfaces.nsIUpdatePrompt);
               updatePrompt.checkForUpdates();
             """)
 
         self.dialog = self.browser.open_window(callback=opener,
                                                expected_window_class=UpdateWizardDialog)
         self.wizard = self.dialog.wizard
 
     def tearDown(self):
         try:
             self.puppeteer.windows.close_all([self.browser])
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(TestUpdateWizard, self).tearDown()
 
     def test_basic(self):
         self.assertEqual(self.dialog.window_type, 'Update:Wizard')
         self.assertNotEqual(self.dialog.dtds, [])
         self.assertNotEqual(self.dialog.properties, [])
 
     def test_elements(self):
         """Test correct retrieval of elements."""
--- a/testing/firefox-ui/tests/puppeteer/test_utils.py
+++ b/testing/firefox-ui/tests/puppeteer/test_utils.py
@@ -3,17 +3,17 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class TestSanitize(FirefoxTestCase):
 
     def setUp(self):
-        FirefoxTestCase.setUp(self)
+        super(TestSanitize, self).setUp()
 
         # Clear all previous history and cookies.
         self.puppeteer.places.remove_all_history()
         self.marionette.delete_all_cookies()
 
         self.urls = [
             'layout/mozilla_projects.html',
             'layout/mozilla.html',
@@ -24,19 +24,16 @@ class TestSanitize(FirefoxTestCase):
 
         # Open the test urls, including the single cookie setting page.
         def load_urls():
             with self.marionette.using_context('content'):
                 for url in self.urls:
                     self.marionette.navigate(url)
         self.puppeteer.places.wait_for_visited(self.urls, load_urls)
 
-    def tearDown(self):
-        FirefoxTestCase.tearDown(self)
-
     def test_sanitize_history(self):
         """ Clears history. """
         self.assertEqual(self.puppeteer.places.get_all_urls_in_history(), self.urls)
         self.puppeteer.utils.sanitize(data_type={"history": True})
         self.assertEqual(self.puppeteer.places.get_all_urls_in_history(), [])
 
     def test_sanitize_cookies(self):
         """ Clears cookies. """
--- a/testing/firefox-ui/tests/puppeteer/test_windows.py
+++ b/testing/firefox-ui/tests/puppeteer/test_windows.py
@@ -7,47 +7,49 @@ from marionette_driver.errors import NoS
 
 import firefox_puppeteer.errors as errors
 
 from firefox_puppeteer.ui.windows import BaseWindow
 from firefox_ui_harness.testcases import FirefoxTestCase
 
 
 class BaseWindowTestCase(FirefoxTestCase):
+
     def setUp(self):
         """
         These tests open and close windows pretty rapidly, which
         (since bug 1261842) can cause content processes to be
         spawned and discarded in large numbers. By default, Firefox
         has a 5 second timeout for shutting down content processes,
         but we can get into cases where the content process just
         doesn't have enough time to get itself all sorted before
         the timeout gets hit, which results in the parent killing
         the content process manually, which generates a crash report,
         which causes these tests to orange. We side-step this by
         setting dom.ipc.tabs.shutdownTimeoutSecs to 0, which disables
         the shutdown timer.
         """
-        FirefoxTestCase.setUp(self)
+        super(BaseWindowTestCase, self).setUp()
+
         self.puppeteer.prefs.set_pref('dom.ipc.tabs.shutdownTimeoutSecs', 0)
 
     def tearDown(self):
         try:
             self.marionette.clear_pref('dom.ipc.tabs.shutdownTimeoutSecs')
         finally:
-            FirefoxTestCase.tearDown(self)
+            super(BaseWindowTestCase, self).tearDown()
 
 
 class TestWindows(BaseWindowTestCase):
 
     def tearDown(self):
         try:
             self.puppeteer.windows.close_all([self.browser])
         finally:
-            BaseWindowTestCase.tearDown(self)
+            super(TestWindows, self).tearDown()
 
     def test_switch_to(self):
         url = self.marionette.absolute_url('layout/mozilla.html')
 
         # Open two more windows
         for index in range(0, 2):
             self.marionette.execute_script(""" window.open(); """)