--- a/browser/components/migration/tests/marionette/test_refresh_firefox.py
+++ b/browser/components/migration/tests/marionette/test_refresh_firefox.py
@@ -36,75 +36,87 @@ class TestFirefoxRefresh(MarionetteTestC
     _formHistoryValue = "special-pumpkin-value"
 
     _formAutofillAvailable = False
     _formAutofillAddressGuid = None
 
     _expectedURLs = ["about:robots", "about:mozilla"]
 
     def savePassword(self):
-        self.runCode("""
+        self.runCode(
+            """
           let myLogin = new global.LoginInfo(
             "test.marionette.mozilla.com",
             "http://test.marionette.mozilla.com/some/form/",
             null,
             arguments[0],
             arguments[1],
             "username",
             "password"
           );
           Services.logins.addLogin(myLogin)
-        """, script_args=(self._username, self._password))
+        """,
+            script_args=(self._username, self._password),
+        )
 
     def createBookmarkInMenu(self):
-        error = self.runAsyncCode("""
+        error = self.runAsyncCode(
+            """
           // let url = arguments[0];
           // let title = arguments[1];
           // let resolve = arguments[arguments.length - 1];
           let [url, title, resolve] = arguments;
           PlacesUtils.bookmarks.insert({
             parentGuid: PlacesUtils.bookmarks.menuGuid, url, title
           }).then(() => resolve(false), resolve);
-        """, script_args=(self._bookmarkURL, self._bookmarkText))
+        """,
+            script_args=(self._bookmarkURL, self._bookmarkText),
+        )
         if error:
             print(error)
 
     def createBookmarksOnToolbar(self):
-        error = self.runAsyncCode("""
+        error = self.runAsyncCode(
+            """
           let resolve = arguments[arguments.length - 1];
           let children = [];
           for (let i = 1; i <= 5; i++) {
             children.push({url: `about:rights?p=${i}`, title: `Bookmark ${i}`});
           }
           PlacesUtils.bookmarks.insertTree({
             guid: PlacesUtils.bookmarks.toolbarGuid,
             children
           }).then(() => resolve(false), resolve);
-        """)
+        """
+        )
         if error:
             print(error)
 
     def createHistory(self):
-        error = self.runAsyncCode("""
+        error = self.runAsyncCode(
+            """
           let resolve = arguments[arguments.length - 1];
           PlacesUtils.history.insert({
             url: arguments[0],
             title: arguments[1],
             visits: [{
               date: new Date(Date.now() - 5000),
               referrer: "about:mozilla"
             }]
           }).then(() => resolve(false),
                   ex => resolve("Unexpected error in adding visit: " + ex));
-        """, script_args=(self._historyURL, self._historyTitle))
+        """,
+            script_args=(self._historyURL, self._historyTitle),
+        )
         if error:
             print(error)
 
     def createFormHistory(self):
-        error = self.runAsyncCode("""
+        error = self.runAsyncCode(
+            """
           let updateDefinition = {
             op: "add",
             fieldname: arguments[0],
             value: arguments[1],
             firstUsed: (Date.now() - 5000) * 1000,
           };
           let finished = false;
           let resolve = arguments[arguments.length - 1];
@@ -114,24 +126,27 @@ class TestFirefoxRefresh(MarionetteTestC
               resolve(error);
             },
             handleCompletion() {
               if (!finished) {
                 resolve(false);
               }
             }
           });
-        """, script_args=(self._formHistoryFieldName, self._formHistoryValue))
+        """,
+            script_args=(self._formHistoryFieldName, self._formHistoryValue),
+        )
         if error:
             print(error)
 
     def createFormAutofill(self):
         if not self._formAutofillAvailable:
             return
-        self._formAutofillAddressGuid = self.runAsyncCode("""
+        self._formAutofillAddressGuid = self.runAsyncCode(
+            """
           let resolve = arguments[arguments.length - 1];
           const TEST_ADDRESS_1 = {
             "given-name": "John",
             "additional-name": "R.",
             "family-name": "Smith",
             organization: "World Wide Web Consortium",
             "street-address": "32 Vassar Street\\\nMIT Room 32-G524",
             "address-level2": "Cambridge",
@@ -139,29 +154,39 @@ class TestFirefoxRefresh(MarionetteTestC
             "postal-code": "02139",
             country: "US",
             tel: "+15195555555",
             email: "user@example.com",
           };
           return global.formAutofillStorage.initialize().then(() => {
             return global.formAutofillStorage.addresses.add(TEST_ADDRESS_1);
           }).then(resolve);
-        """)
+        """
+        )
 
     def createCookie(self):
-        self.runCode("""
+        self.runCode(
+            """
           // Expire in 15 minutes:
           let expireTime = Math.floor(Date.now() / 1000) + 15 * 60;
           Services.cookies.add(arguments[0], arguments[1], arguments[2], arguments[3],
                                true, false, false, expireTime, {},
                                Ci.nsICookie.SAMESITE_NONE, Ci.nsICookie.SCHEME_UNSET);
-        """, script_args=(self._cookieHost, self._cookiePath, self._cookieName, self._cookieValue))
+        """,
+            script_args=(
+                self._cookieHost,
+                self._cookiePath,
+                self._cookieName,
+                self._cookieValue,
+            ),
+        )
 
     def createSession(self):
-        self.runAsyncCode("""
+        self.runAsyncCode(
+            """
           let resolve = arguments[arguments.length - 1];
           const COMPLETE_STATE = Ci.nsIWebProgressListener.STATE_STOP +
                                  Ci.nsIWebProgressListener.STATE_IS_NETWORK;
           let {TabStateFlusher} = Cu.import("resource:///modules/sessionstore/TabStateFlusher.jsm", {});
           let expectedURLs = Array.from(arguments[0])
           gBrowser.addTabsProgressListener({
             onStateChange(browser, webprogress, request, flags, status) {
               try {
@@ -188,197 +213,234 @@ class TestFirefoxRefresh(MarionetteTestC
           }
           // Close any other tabs that might be open:
           let allTabs = Array.from(gBrowser.tabs);
           for (let tab of allTabs) {
             if (!expectedTabs.has(tab)) {
               gBrowser.removeTab(tab);
             }
           }
-        """, script_args=(self._expectedURLs,))  # NOQA: E501
+        """,  # NOQA: E501
+            script_args=(self._expectedURLs,),
+        )
 
     def createFxa(self):
         # This script will write an entry to the login manager and create
         # a signedInUser.json in the profile dir.
-        self.runAsyncCode("""
+        self.runAsyncCode(
+            """
           let resolve = arguments[arguments.length - 1];
           Cu.import("resource://gre/modules/FxAccountsStorage.jsm");
           let storage = new FxAccountsStorageManager();
           let data = {email: "test@test.com", uid: "uid", keyFetchToken: "top-secret"};
           storage.initialize(data);
           storage.finalize().then(resolve);
-        """)
+        """
+        )
 
     def createSync(self):
         # This script will write the canonical preference which indicates a user
         # is signed into sync.
-        self.marionette.execute_script("""
+        self.marionette.execute_script(
+            """
             Services.prefs.setStringPref("services.sync.username", "test@test.com");
-        """)
+        """
+        )
 
     def checkPassword(self):
-        loginInfo = self.marionette.execute_script("""
+        loginInfo = self.marionette.execute_script(
+            """
           let ary = Services.logins.findLogins(
             "test.marionette.mozilla.com",
             "http://test.marionette.mozilla.com/some/form/",
             null, {});
           return ary.length ? ary : {username: "null", password: "null"};
-        """)
+        """
+        )
         self.assertEqual(len(loginInfo), 1)
-        self.assertEqual(loginInfo[0]['username'], self._username)
-        self.assertEqual(loginInfo[0]['password'], self._password)
+        self.assertEqual(loginInfo[0]["username"], self._username)
+        self.assertEqual(loginInfo[0]["password"], self._password)
 
-        loginCount = self.marionette.execute_script("""
+        loginCount = self.marionette.execute_script(
+            """
           return Services.logins.getAllLogins().length;
-        """)
+        """
+        )
         # Note that we expect 2 logins - one from us, one from sync.
         self.assertEqual(loginCount, 2, "No other logins are present")
 
     def checkBookmarkInMenu(self):
-        titleInBookmarks = self.runAsyncCode("""
+        titleInBookmarks = self.runAsyncCode(
+            """
           let [url, resolve] = arguments;
           PlacesUtils.bookmarks.fetch({url}).then(
             bookmark => resolve(bookmark ? bookmark.title : ""),
             ex => resolve(ex)
           );
-        """, script_args=(self._bookmarkURL,))
+        """,
+            script_args=(self._bookmarkURL,),
+        )
         self.assertEqual(titleInBookmarks, self._bookmarkText)
 
     def checkBookmarkToolbarVisibility(self):
-        toolbarVisible = self.marionette.execute_script("""
+        toolbarVisible = self.marionette.execute_script(
+            """
           const BROWSER_DOCURL = AppConstants.BROWSER_CHROME_URL;
           return Services.xulStore.getValue(BROWSER_DOCURL, "PersonalToolbar", "collapsed");
-        """)
+        """
+        )
         if toolbarVisible == "":
             toolbarVisible = "false"
         self.assertEqual(toolbarVisible, "false")
 
     def checkHistory(self):
-        historyResult = self.runAsyncCode("""
+        historyResult = self.runAsyncCode(
+            """
           let resolve = arguments[arguments.length - 1];
           PlacesUtils.history.fetch(arguments[0]).then(pageInfo => {
             if (!pageInfo) {
               resolve("No visits found");
             } else {
               resolve(pageInfo);
             }
           }).catch(e => {
             resolve("Unexpected error in fetching page: " + e);
           });
-        """, script_args=(self._historyURL,))
+        """,
+            script_args=(self._historyURL,),
+        )
         if type(historyResult) == str:
             self.fail(historyResult)
             return
 
-        self.assertEqual(historyResult['title'], self._historyTitle)
+        self.assertEqual(historyResult["title"], self._historyTitle)
 
     def checkFormHistory(self):
-        formFieldResults = self.runAsyncCode("""
+        formFieldResults = self.runAsyncCode(
+            """
           let resolve = arguments[arguments.length - 1];
           let results = [];
           global.FormHistory.search(["value"], {fieldname: arguments[0]}, {
             handleError(error) {
               results = error;
             },
             handleResult(result) {
               results.push(result);
             },
             handleCompletion() {
               resolve(results);
             },
           });
-        """, script_args=(self._formHistoryFieldName,))
+        """,
+            script_args=(self._formHistoryFieldName,),
+        )
         if type(formFieldResults) == str:
             self.fail(formFieldResults)
             return
 
         formFieldResultCount = len(formFieldResults)
-        self.assertEqual(formFieldResultCount, 1,
-                         "Should have exactly 1 entry for this field, got %d" %
-                         formFieldResultCount)
+        self.assertEqual(
+            formFieldResultCount,
+            1,
+            "Should have exactly 1 entry for this field, got %d" % formFieldResultCount,
+        )
         if formFieldResultCount == 1:
-            self.assertEqual(
-                formFieldResults[0]['value'], self._formHistoryValue)
+            self.assertEqual(formFieldResults[0]["value"], self._formHistoryValue)
 
-        formHistoryCount = self.runAsyncCode("""
+        formHistoryCount = self.runAsyncCode(
+            """
           let [resolve] = arguments;
           let count;
           let callbacks = {
             handleResult: rv => count = rv,
             handleCompletion() {
               resolve(count);
             },
           };
           global.FormHistory.count({}, callbacks);
-        """)
-        self.assertEqual(formHistoryCount, 1,
-                         "There should be only 1 entry in the form history")
+        """
+        )
+        self.assertEqual(
+            formHistoryCount, 1, "There should be only 1 entry in the form history"
+        )
 
     def checkFormAutofill(self):
         if not self._formAutofillAvailable:
             return
 
-        formAutofillResults = self.runAsyncCode("""
+        formAutofillResults = self.runAsyncCode(
+            """
           let resolve = arguments[arguments.length - 1];
           return global.formAutofillStorage.initialize().then(() => {
             return global.formAutofillStorage.addresses.getAll()
           }).then(resolve);
-        """,)
+        """,
+        )
         if type(formAutofillResults) == str:
             self.fail(formAutofillResults)
             return
 
         formAutofillAddressCount = len(formAutofillResults)
-        self.assertEqual(formAutofillAddressCount, 1,
-                         "Should have exactly 1 saved address, got %d" % formAutofillAddressCount)
+        self.assertEqual(
+            formAutofillAddressCount,
+            1,
+            "Should have exactly 1 saved address, got %d" % formAutofillAddressCount,
+        )
         if formAutofillAddressCount == 1:
             self.assertEqual(
-                formAutofillResults[0]['guid'], self._formAutofillAddressGuid)
+                formAutofillResults[0]["guid"], self._formAutofillAddressGuid
+            )
 
     def checkCookie(self):
-        cookieInfo = self.runCode("""
+        cookieInfo = self.runCode(
+            """
           try {
             let cookies = Services.cookies.getCookiesFromHost(arguments[0], {});
             let cookie = null;
             for (let hostCookie of cookies) {
               // getCookiesFromHost returns any cookie from the BASE host.
               if (hostCookie.rawHost != arguments[0])
                 continue;
               if (cookie != null) {
                 return "more than 1 cookie! That shouldn't happen!";
               }
               cookie = hostCookie;
             }
             return {path: cookie.path, name: cookie.name, value: cookie.value};
           } catch (ex) {
             return "got exception trying to fetch cookie: " + ex;
           }
-        """, script_args=(self._cookieHost,))
+        """,
+            script_args=(self._cookieHost,),
+        )
         if not isinstance(cookieInfo, dict):
             self.fail(cookieInfo)
             return
-        self.assertEqual(cookieInfo['path'], self._cookiePath)
-        self.assertEqual(cookieInfo['value'], self._cookieValue)
-        self.assertEqual(cookieInfo['name'], self._cookieName)
+        self.assertEqual(cookieInfo["path"], self._cookiePath)
+        self.assertEqual(cookieInfo["value"], self._cookieValue)
+        self.assertEqual(cookieInfo["name"], self._cookieName)
 
     def checkSession(self):
-        tabURIs = self.runCode("""
+        tabURIs = self.runCode(
+            """
           return [... gBrowser.browsers].map(b => b.currentURI && b.currentURI.spec)
-        """)
+        """
+        )
         self.assertSequenceEqual(tabURIs, ["about:welcomeback"])
 
         # Dismiss modal dialog if any. This is mainly to dismiss the check for
         # default browser dialog if it shows up.
         try:
             alert = self.marionette.switch_to_alert()
             alert.dismiss()
         except NoAlertPresentException:
             pass
 
-        tabURIs = self.runAsyncCode("""
+        tabURIs = self.runAsyncCode(
+            """
           let resolve = arguments[arguments.length - 1]
           let mm = gBrowser.selectedBrowser.messageManager;
 
           let {TabStateFlusher} = Cu.import("resource:///modules/sessionstore/TabStateFlusher.jsm", {});
           window.addEventListener("SSWindowStateReady", function testSSPostReset() {
             window.removeEventListener("SSWindowStateReady", testSSPostReset, false);
             Promise.all(gBrowser.browsers.map(b => TabStateFlusher.flush(b))).then(function() {
               resolve([... gBrowser.browsers].map(b => b.currentURI && b.currentURI.spec));
@@ -391,46 +453,51 @@ class TestFirefoxRefresh(MarionetteTestC
             } else {
               content.window.addEventListener("load", function(event) {
                 content.document.getElementById("errorTryAgain").click();
               }, { once: true });
             }
           };
 
           mm.loadFrameScript("data:application/javascript,(" + fs.toString() + ")()", true);
-        """)  # NOQA: E501
+        """  # NOQA: E501
+        )
         self.assertSequenceEqual(tabURIs, self._expectedURLs)
 
     def checkFxA(self):
-        result = self.runAsyncCode("""
+        result = self.runAsyncCode(
+            """
           Cu.import("resource://gre/modules/FxAccountsStorage.jsm");
           let resolve = arguments[arguments.length - 1];
           let storage = new FxAccountsStorageManager();
           let result = {};
           storage.initialize();
           storage.getAccountData().then(data => {
             result.accountData = data;
             return storage.finalize();
           }).then(() => {
             resolve(result);
           }).catch(err => {
             resolve(err.toString());
           });
-        """)
+        """
+        )
         if type(result) != dict:
             self.fail(result)
             return
         self.assertEqual(result["accountData"]["email"], "test@test.com")
         self.assertEqual(result["accountData"]["uid"], "uid")
         self.assertEqual(result["accountData"]["keyFetchToken"], "top-secret")
 
     def checkSync(self, expect_sync_user):
-        pref_value = self.marionette.execute_script("""
+        pref_value = self.marionette.execute_script(
+            """
             return Services.prefs.getStringPref("services.sync.username", null);
-        """)
+        """
+        )
         expected_value = "test@test.com" if expect_sync_user else None
         self.assertEqual(pref_value, expected_value)
 
     def checkProfile(self, has_migrated=False, expect_sync_user=True):
         self.checkPassword()
         self.checkBookmarkInMenu()
         self.checkHistory()
         self.checkFormHistory()
@@ -451,45 +518,45 @@ class TestFirefoxRefresh(MarionetteTestC
         self.createFormAutofill()
         self.createCookie()
         self.createSession()
         self.createFxa()
         self.createSync()
 
     def setUpScriptData(self):
         self.marionette.set_context(self.marionette.CONTEXT_CHROME)
-        self.runCode("""
+        self.runCode(
+            """
           window.global = {};
           global.LoginInfo = Components.Constructor("@mozilla.org/login-manager/loginInfo;1", "nsILoginInfo", "init");
           global.profSvc = Cc["@mozilla.org/toolkit/profile-service;1"].getService(Ci.nsIToolkitProfileService);
           global.Preferences = Cu.import("resource://gre/modules/Preferences.jsm", {}).Preferences;
           global.FormHistory = Cu.import("resource://gre/modules/FormHistory.jsm", {}).FormHistory;
-        """)  # NOQA: E501
-        self._formAutofillAvailable = self.runCode("""
+        """  # NOQA: E501
+        )
+        self._formAutofillAvailable = self.runCode(
+            """
           try {
             global.formAutofillStorage = Cu.import("resource://formautofill/FormAutofillStorage.jsm", {}).formAutofillStorage;
           } catch(e) {
             return false;
           }
           return true;
-        """)  # NOQA: E501
+        """  # NOQA: E501
+        )
 
     def runCode(self, script, *args, **kwargs):
-        return self.marionette.execute_script(script,
-                                              new_sandbox=False,
-                                              sandbox=self._sandbox,
-                                              *args,
-                                              **kwargs)
+        return self.marionette.execute_script(
+            script, new_sandbox=False, sandbox=self._sandbox, *args, **kwargs
+        )
 
     def runAsyncCode(self, script, *args, **kwargs):
-        return self.marionette.execute_async_script(script,
-                                                    new_sandbox=False,
-                                                    sandbox=self._sandbox,
-                                                    *args,
-                                                    **kwargs)
+        return self.marionette.execute_async_script(
+            script, new_sandbox=False, sandbox=self._sandbox, *args, **kwargs
+        )
 
     def setUp(self):
         MarionetteTestCase.setUp(self)
         self.setUpScriptData()
 
         self.cleanups = []
 
     def tearDown(self):
@@ -506,34 +573,40 @@ class TestFirefoxRefresh(MarionetteTestC
         import mozfile
 
         for cleanup in self.cleanups:
             if cleanup.desktop_backup_path:
                 mozfile.remove(cleanup.desktop_backup_path)
 
             if cleanup.reset_profile_path:
                 # Remove ourselves from profiles.ini
-                self.runCode("""
+                self.runCode(
+                    """
                   let name = arguments[0];
                   let profile = global.profSvc.getProfileByName(name);
                   profile.remove(false)
                   global.profSvc.flush();
-                """, script_args=(cleanup.profile_name_to_remove,))
+                """,
+                    script_args=(cleanup.profile_name_to_remove,),
+                )
                 # Remove the local profile dir if it's not the same as the profile dir:
-                different_path = cleanup.reset_profile_local_path != cleanup.reset_profile_path
+                different_path = (
+                    cleanup.reset_profile_local_path != cleanup.reset_profile_path
+                )
                 if cleanup.reset_profile_local_path and different_path:
                     mozfile.remove(cleanup.reset_profile_local_path)
 
                 # And delete all the files.
                 mozfile.remove(cleanup.reset_profile_path)
 
     def doReset(self):
         profileName = "marionette-test-profile-" + str(int(time.time() * 1000))
         cleanup = PendingCleanup(profileName)
-        self.runCode("""
+        self.runCode(
+            """
           // Ensure the current (temporary) profile is in profiles.ini:
           let profD = Services.dirsvc.get("ProfD", Ci.nsIFile);
           let profileName = arguments[1];
           let myProfile = global.profSvc.createProfile(profD, profileName);
           global.profSvc.flush()
 
           // Now add the reset parameters:
           let env = Cc["@mozilla.org/process/environment;1"].getService(Ci.nsIEnvironment);
@@ -541,51 +614,66 @@ class TestFirefoxRefresh(MarionetteTestC
           prefsToKeep.push("datareporting.policy.dataSubmissionPolicyBypassNotification");
           let prefObj = {};
           for (let pref of prefsToKeep) {
             prefObj[pref] = global.Preferences.get(pref);
           }
           env.set("MOZ_MARIONETTE_PREF_STATE_ACROSS_RESTARTS", JSON.stringify(prefObj));
           env.set("MOZ_RESET_PROFILE_RESTART", "1");
           env.set("XRE_PROFILE_PATH", arguments[0]);
-        """, script_args=(self.marionette.instance.profile.profile, profileName,))
+        """,
+            script_args=(
+                self.marionette.instance.profile.profile,
+                profileName,
+            ),
+        )
 
-        profileLeafName = os.path.basename(os.path.normpath(
-            self.marionette.instance.profile.profile))
+        profileLeafName = os.path.basename(
+            os.path.normpath(self.marionette.instance.profile.profile)
+        )
 
         # Now restart the browser to get it reset:
         self.marionette.restart(clean=False, in_app=True)
         self.setUpScriptData()
 
         # Determine the new profile path (we'll need to remove it when we're done)
-        [cleanup.reset_profile_path, cleanup.reset_profile_local_path] = self.runCode("""
+        [cleanup.reset_profile_path, cleanup.reset_profile_local_path] = self.runCode(
+            """
           let profD = Services.dirsvc.get("ProfD", Ci.nsIFile);
           let localD = Services.dirsvc.get("ProfLD", Ci.nsIFile);
           return [profD.path, localD.path];
-        """)
+        """
+        )
 
         # Determine the backup path
-        cleanup.desktop_backup_path = self.runCode("""
+        cleanup.desktop_backup_path = self.runCode(
+            """
           let container;
           try {
             container = Services.dirsvc.get("Desk", Ci.nsIFile);
           } catch (ex) {
             container = Services.dirsvc.get("Home", Ci.nsIFile);
           }
           let bundle = Services.strings.createBundle("chrome://mozapps/locale/profile/profileSelection.properties");
           let dirName = bundle.formatStringFromName("resetBackupDirectory", [Services.appinfo.name]);
           container.append(dirName);
           container.append(arguments[0]);
           return container.path;
-        """, script_args=(profileLeafName,))  # NOQA: E501
+        """,  # NOQA: E501
+            script_args=(profileLeafName,),
+        )
 
-        self.assertTrue(os.path.isdir(cleanup.reset_profile_path),
-                        "Reset profile path should be present")
-        self.assertTrue(os.path.isdir(cleanup.desktop_backup_path),
-                        "Backup profile path should be present")
+        self.assertTrue(
+            os.path.isdir(cleanup.reset_profile_path),
+            "Reset profile path should be present",
+        )
+        self.assertTrue(
+            os.path.isdir(cleanup.desktop_backup_path),
+            "Backup profile path should be present",
+        )
         self.assertIn(cleanup.profile_name_to_remove, cleanup.reset_profile_path)
         return cleanup
 
     def testResetEverything(self):
         self.createProfileData()
 
         self.checkProfile(expect_sync_user=True)
 

--- a/build/pgo/genpgocert.py
+++ b/build/pgo/genpgocert.py
@@ -18,17 +18,17 @@ import sys
 from mozbuild.base import MozbuildObject, BinaryNotFoundException
 from mozfile import NamedTemporaryFile, TemporaryDirectory
 from mozprofile.permissions import ServerLocations
 from distutils.spawn import find_executable
 
 dbFiles = [
     re.compile("^cert[0-9]+\.db$"),
     re.compile("^key[0-9]+\.db$"),
-    re.compile("^secmod\.db$")
+    re.compile("^secmod\.db$"),
 ]
 
 
 def unlinkDbFiles(path):
     for root, dirs, files in os.walk(path):
         for name in files:
             for dbFile in dbFiles:
                 if dbFile.match(name) and os.path.exists(os.path.join(root, name)):
@@ -48,162 +48,207 @@ def runUtil(util, args, inputdata=None, 
     env = os.environ.copy()
     if mozinfo.os == "linux":
         pathvar = "LD_LIBRARY_PATH"
         app_path = os.path.dirname(util)
         if pathvar in env:
             env[pathvar] = "%s%s%s" % (app_path, os.pathsep, env[pathvar])
         else:
             env[pathvar] = app_path
-    proc = subprocess.Popen([util] + args, env=env,
-                            stdin=subprocess.PIPE if inputdata else None,
-                            stdout=outputstream,
-                            universal_newlines=True)
+    proc = subprocess.Popen(
+        [util] + args,
+        env=env,
+        stdin=subprocess.PIPE if inputdata else None,
+        stdout=outputstream,
+        universal_newlines=True,
+    )
     proc.communicate(inputdata)
     return proc.returncode
 
 
 def createRandomFile(randomFile):
     for count in xrange(0, 2048):
         randomFile.write(chr(random.randint(0, 255)))
 
 
 def writeCertspecForServerLocations(fd):
-    locations = ServerLocations(os.path.join(build.topsrcdir,
-                                             "build", "pgo",
-                                             "server-locations.txt"))
+    locations = ServerLocations(
+        os.path.join(build.topsrcdir, "build", "pgo", "server-locations.txt")
+    )
     SAN = []
-    for loc in [i for i in iter(locations) if i.scheme == "https" and "nocert" not in i.options]:
+    for loc in [
+        i for i in iter(locations) if i.scheme == "https" and "nocert" not in i.options
+    ]:
         customCertOption = False
         customCertRE = re.compile("^cert=(?:\w+)")
         for _ in [i for i in loc.options if customCertRE.match(i)]:
             customCertOption = True
             break
 
         if "ipV4Address" in loc.options:
             loc.host = "ip4:" + loc.host
 
         if not customCertOption:
             SAN.append(loc.host)
 
-    fd.write("issuer:printableString/CN=Temporary Certificate Authority/O=Mozilla Testing/OU=Profile Guided Optimization\n")  # NOQA: E501
+    fd.write(
+        "issuer:printableString/CN=Temporary Certificate Authority/O=Mozilla Testing/OU=Profile Guided Optimization\n"  # NOQA: E501
+    )
     fd.write("subject:{}\n".format(SAN[0]))
     fd.write("extension:subjectAlternativeName:{}\n".format(",".join(SAN)))
 
 
 def constructCertDatabase(build, srcDir):
     try:
         certutil = build.get_binary_path(what="certutil")
         pk12util = build.get_binary_path(what="pk12util")
     except BinaryNotFoundException as e:
-        print('{}\n\n{}\n'.format(e, e.help()))
+        print("{}\n\n{}\n".format(e, e.help()))
         return 1
     openssl = find_executable("openssl")
-    pycert = os.path.join(build.topsrcdir, "security", "manager", "ssl", "tests",
-                          "unit", "pycert.py")
-    pykey = os.path.join(build.topsrcdir, "security", "manager", "ssl", "tests",
-                         "unit", "pykey.py")
+    pycert = os.path.join(
+        build.topsrcdir, "security", "manager", "ssl", "tests", "unit", "pycert.py"
+    )
+    pykey = os.path.join(
+        build.topsrcdir, "security", "manager", "ssl", "tests", "unit", "pykey.py"
+    )
 
     with NamedTemporaryFile(mode="wt+") as pwfile, TemporaryDirectory() as pemfolder:
         pwfile.write("\n")
         pwfile.flush()
 
         if dbFilesExist(srcDir):
             # Make sure all DB files from src are really deleted
             unlinkDbFiles(srcDir)
 
         # Copy  all .certspec and .keyspec files to a temporary directory
         for root, dirs, files in os.walk(srcDir):
-            for spec in [i for i in files if i.endswith(".certspec") or i.endswith(".keyspec")]:
-                shutil.copyfile(os.path.join(root, spec),
-                                os.path.join(pemfolder, spec))
+            for spec in [
+                i for i in files if i.endswith(".certspec") or i.endswith(".keyspec")
+            ]:
+                shutil.copyfile(os.path.join(root, spec), os.path.join(pemfolder, spec))
 
         # Write a certspec for the "server-locations.txt" file to that temporary directory
         pgoserver_certspec = os.path.join(pemfolder, "pgoserver.certspec")
         if os.path.exists(pgoserver_certspec):
             raise Exception(
-                "{} already exists, which isn't allowed".format(pgoserver_certspec))
+                "{} already exists, which isn't allowed".format(pgoserver_certspec)
+            )
         with open(pgoserver_certspec, "w") as fd:
             writeCertspecForServerLocations(fd)
 
         # Generate certs for all certspecs
         for root, dirs, files in os.walk(pemfolder):
             for certspec in [i for i in files if i.endswith(".certspec")]:
                 name = certspec.split(".certspec")[0]
                 pem = os.path.join(pemfolder, "{}.cert.pem".format(name))
 
                 print("Generating public certificate {} (pem={})".format(name, pem))
 
                 with open(os.path.join(root, certspec), "r") as certspec_file:
                     certspec_data = certspec_file.read()
                     with open(pem, "w") as pem_file:
                         status = runUtil(
-                            pycert, [], inputdata=certspec_data, outputstream=pem_file)
+                            pycert, [], inputdata=certspec_data, outputstream=pem_file
+                        )
                         if status:
                             return status
 
-                status = runUtil(certutil, [
-                                 "-A", "-n", name, "-t", "P,,", "-i", pem,
-                                 "-d", srcDir, "-f", pwfile.name
-                                 ])
+                status = runUtil(
+                    certutil,
+                    [
+                        "-A",
+                        "-n",
+                        name,
+                        "-t",
+                        "P,,",
+                        "-i",
+                        pem,
+                        "-d",
+                        srcDir,
+                        "-f",
+                        pwfile.name,
+                    ],
+                )
                 if status:
                     return status
 
             for keyspec in [i for i in files if i.endswith(".keyspec")]:
                 parts = keyspec.split(".")
                 name = parts[0]
                 key_type = parts[1]
                 if key_type not in ["ca", "client", "server"]:
-                    raise Exception("{}: keyspec filenames must be of the form XXX.client.keyspec "
-                                    "or XXX.ca.keyspec (key_type={})".format(
-                                        keyspec, key_type))
+                    raise Exception(
+                        "{}: keyspec filenames must be of the form XXX.client.keyspec "
+                        "or XXX.ca.keyspec (key_type={})".format(keyspec, key_type)
+                    )
                 key_pem = os.path.join(pemfolder, "{}.key.pem".format(name))
 
                 print("Generating private key {} (pem={})".format(name, key_pem))
 
                 with open(os.path.join(root, keyspec), "r") as keyspec_file:
                     keyspec_data = keyspec_file.read()
                     with open(key_pem, "w") as pem_file:
                         status = runUtil(
-                            pykey, [], inputdata=keyspec_data, outputstream=pem_file)
+                            pykey, [], inputdata=keyspec_data, outputstream=pem_file
+                        )
                         if status:
                             return status
 
                 cert_pem = os.path.join(pemfolder, "{}.cert.pem".format(name))
                 if not os.path.exists(cert_pem):
-                    raise Exception("There has to be a corresponding certificate named {} for "
-                                    "the keyspec {}".format(
-                                        cert_pem, keyspec))
+                    raise Exception(
+                        "There has to be a corresponding certificate named {} for "
+                        "the keyspec {}".format(cert_pem, keyspec)
+                    )
 
                 p12 = os.path.join(pemfolder, "{}.key.p12".format(name))
-                print("Converting private key {} to PKCS12 (p12={})".format(
-                    key_pem, p12))
-                status = runUtil(openssl, ["pkcs12", "-export", "-inkey", key_pem, "-in",
-                                           cert_pem, "-name", name, "-out", p12, "-passout",
-                                           "file:"+pwfile.name])
+                print(
+                    "Converting private key {} to PKCS12 (p12={})".format(key_pem, p12)
+                )
+                status = runUtil(
+                    openssl,
+                    [
+                        "pkcs12",
+                        "-export",
+                        "-inkey",
+                        key_pem,
+                        "-in",
+                        cert_pem,
+                        "-name",
+                        name,
+                        "-out",
+                        p12,
+                        "-passout",
+                        "file:" + pwfile.name,
+                    ],
+                )
                 if status:
                     return status
 
                 print("Importing private key {} to database".format(key_pem))
                 status = runUtil(
-                    pk12util, ["-i", p12, "-d", srcDir, "-w", pwfile.name, "-k", pwfile.name])
+                    pk12util,
+                    ["-i", p12, "-d", srcDir, "-w", pwfile.name, "-k", pwfile.name],
+                )
                 if status:
                     return status
 
                 if key_type == "ca":
-                    shutil.copyfile(cert_pem, os.path.join(
-                        srcDir, "{}.ca".format(name)))
+                    shutil.copyfile(
+                        cert_pem, os.path.join(srcDir, "{}.ca".format(name))
+                    )
                 elif key_type == "client":
-                    shutil.copyfile(p12, os.path.join(
-                        srcDir, "{}.client".format(name)))
+                    shutil.copyfile(p12, os.path.join(srcDir, "{}.client".format(name)))
                 elif key_type == "server":
                     pass  # Nothing to do for server keys
                 else:
                     raise Exception(
-                        "State error: Unknown keyspec key_type: {}".format(key_type))
+                        "State error: Unknown keyspec key_type: {}".format(key_type)
+                    )
 
     return 0
 
 
 build = MozbuildObject.from_environment()
 certdir = os.path.join(build.topsrcdir, "build", "pgo", "certs")
 certificateStatus = constructCertDatabase(build, certdir)
 if certificateStatus:

--- a/config/check_macroassembler_style.py
+++ b/config/check_macroassembler_style.py
@@ -23,321 +23,320 @@
 from __future__ import absolute_import
 from __future__ import print_function
 
 import difflib
 import os
 import re
 import sys
 
-architecture_independent = set(['generic'])
-all_unsupported_architectures_names = set(['mips32', 'mips64', 'mips_shared'])
-all_architecture_names = set(['x86', 'x64', 'arm', 'arm64'])
-all_shared_architecture_names = set(['x86_shared', 'arm', 'arm64'])
+architecture_independent = set(["generic"])
+all_unsupported_architectures_names = set(["mips32", "mips64", "mips_shared"])
+all_architecture_names = set(["x86", "x64", "arm", "arm64"])
+all_shared_architecture_names = set(["x86_shared", "arm", "arm64"])
 
 reBeforeArg = "(?<=[(,\s])"
 reArgType = "(?P<type>[\w\s:*&]+)"
 reArgName = "(?P<name>\s\w+)"
 reArgDefault = "(?P<default>(?:\s=[^,)]+)?)"
 reAfterArg = "(?=[,)])"
-reMatchArg = re.compile(reBeforeArg + reArgType +
-                        reArgName + reArgDefault + reAfterArg)
+reMatchArg = re.compile(reBeforeArg + reArgType + reArgName + reArgDefault + reAfterArg)
 
 
 def get_normalized_signatures(signature, fileAnnot=None):
     # Remove static
-    signature = signature.replace('static', '')
+    signature = signature.replace("static", "")
     # Remove semicolon.
-    signature = signature.replace(';', ' ')
+    signature = signature.replace(";", " ")
     # Normalize spaces.
-    signature = re.sub(r'\s+', ' ', signature).strip()
+    signature = re.sub(r"\s+", " ", signature).strip()
     # Remove new-line induced spaces after opening braces.
-    signature = re.sub(r'\(\s+', '(', signature).strip()
+    signature = re.sub(r"\(\s+", "(", signature).strip()
     # Match arguments, and keep only the type.
-    signature = reMatchArg.sub('\g<type>', signature)
+    signature = reMatchArg.sub("\g<type>", signature)
     # Remove class name
-    signature = signature.replace('MacroAssembler::', '')
+    signature = signature.replace("MacroAssembler::", "")
 
     # Extract list of architectures
-    archs = ['generic']
+    archs = ["generic"]
     if fileAnnot:
-        archs = [fileAnnot['arch']]
+        archs = [fileAnnot["arch"]]
 
-    if 'DEFINED_ON(' in signature:
+    if "DEFINED_ON(" in signature:
         archs = re.sub(
-            r'.*DEFINED_ON\((?P<archs>[^()]*)\).*', '\g<archs>', signature).split(',')
+            r".*DEFINED_ON\((?P<archs>[^()]*)\).*", "\g<archs>", signature
+        ).split(",")
         archs = [a.strip() for a in archs]
-        signature = re.sub(r'\s+DEFINED_ON\([^()]*\)', '', signature)
+        signature = re.sub(r"\s+DEFINED_ON\([^()]*\)", "", signature)
 
-    elif 'PER_ARCH' in signature:
+    elif "PER_ARCH" in signature:
         archs = all_architecture_names
-        signature = re.sub(r'\s+PER_ARCH', '', signature)
+        signature = re.sub(r"\s+PER_ARCH", "", signature)
 
-    elif 'PER_SHARED_ARCH' in signature:
+    elif "PER_SHARED_ARCH" in signature:
         archs = all_shared_architecture_names
-        signature = re.sub(r'\s+PER_SHARED_ARCH', '', signature)
+        signature = re.sub(r"\s+PER_SHARED_ARCH", "", signature)
 
-    elif 'OOL_IN_HEADER' in signature:
-        assert archs == ['generic']
-        signature = re.sub(r'\s+OOL_IN_HEADER', '', signature)
+    elif "OOL_IN_HEADER" in signature:
+        assert archs == ["generic"]
+        signature = re.sub(r"\s+OOL_IN_HEADER", "", signature)
 
     else:
         # No signature annotation, the list of architectures remains unchanged.
         pass
 
     # Extract inline annotation
     inline = False
     if fileAnnot:
-        inline = fileAnnot['inline']
+        inline = fileAnnot["inline"]
 
-    if 'inline ' in signature:
-        signature = re.sub(r'inline\s+', '', signature)
+    if "inline " in signature:
+        signature = re.sub(r"inline\s+", "", signature)
         inline = True
 
-    inlinePrefx = ''
+    inlinePrefx = ""
     if inline:
-        inlinePrefx = 'inline '
-    signatures = [
-        {'arch': a, 'sig': inlinePrefx + signature}
-        for a in archs
-    ]
+        inlinePrefx = "inline "
+    signatures = [{"arch": a, "sig": inlinePrefx + signature} for a in archs]
 
     return signatures
 
 
-file_suffixes = set([
-    a.replace('_', '-') for a in
-    all_architecture_names.union(all_shared_architecture_names)
-                          .union(all_unsupported_architectures_names)
-])
+file_suffixes = set(
+    [
+        a.replace("_", "-")
+        for a in all_architecture_names.union(all_shared_architecture_names).union(
+            all_unsupported_architectures_names
+        )
+    ]
+)
 
 
 def get_file_annotation(filename):
     origFilename = filename
-    filename = filename.split('/')[-1]
+    filename = filename.split("/")[-1]
 
     inline = False
-    if filename.endswith('.cpp'):
-        filename = filename[:-len('.cpp')]
-    elif filename.endswith('-inl.h'):
+    if filename.endswith(".cpp"):
+        filename = filename[: -len(".cpp")]
+    elif filename.endswith("-inl.h"):
         inline = True
-        filename = filename[:-len('-inl.h')]
-    elif filename.endswith('.h'):
+        filename = filename[: -len("-inl.h")]
+    elif filename.endswith(".h"):
         # This allows the definitions block in MacroAssembler.h to be
         # style-checked.
         inline = True
-        filename = filename[:-len('.h')]
+        filename = filename[: -len(".h")]
     else:
-        raise Exception('unknown file name', origFilename)
+        raise Exception("unknown file name", origFilename)
 
-    arch = 'generic'
+    arch = "generic"
     for suffix in file_suffixes:
-        if filename == 'MacroAssembler-' + suffix:
+        if filename == "MacroAssembler-" + suffix:
             arch = suffix
             break
 
-    return {
-        'inline': inline,
-        'arch': arch.replace('-', '_')
-    }
+    return {"inline": inline, "arch": arch.replace("-", "_")}
 
 
 def get_macroassembler_definitions(filename):
     try:
         fileAnnot = get_file_annotation(filename)
     except Exception:
         return []
 
     style_section = False
-    lines = ''
+    lines = ""
     signatures = []
     with open(filename) as f:
         for line in f:
-            if '//{{{ check_macroassembler_style' in line:
+            if "//{{{ check_macroassembler_style" in line:
                 if style_section:
-                    raise 'check_macroassembler_style section already opened.'
+                    raise "check_macroassembler_style section already opened."
                 style_section = True
                 braces_depth = 0
-            elif '//}}} check_macroassembler_style' in line:
+            elif "//}}} check_macroassembler_style" in line:
                 style_section = False
             if not style_section:
                 continue
 
             # Ignore preprocessor directives.
-            if line.startswith('#'):
+            if line.startswith("#"):
                 continue
 
             # Remove comments from the processed line.
-            line = re.sub(r'//.*', '', line)
+            line = re.sub(r"//.*", "", line)
 
             # Locate and count curly braces.
-            open_curly_brace = line.find('{')
+            open_curly_brace = line.find("{")
             was_braces_depth = braces_depth
-            braces_depth = braces_depth + line.count('{') - line.count('}')
+            braces_depth = braces_depth + line.count("{") - line.count("}")
 
             # Raise an error if the check_macroassembler_style macro is used
             # across namespaces / classes scopes.
             if braces_depth < 0:
-                raise 'check_macroassembler_style annotations are not well scoped.'
+                raise "check_macroassembler_style annotations are not well scoped."
 
             # If the current line contains an opening curly brace, check if
             # this line combines with the previous one can be identified as a
             # MacroAssembler function signature.
             if open_curly_brace != -1 and was_braces_depth == 0:
                 lines = lines + line[:open_curly_brace]
-                if 'MacroAssembler::' in lines:
-                    signatures.extend(
-                        get_normalized_signatures(lines, fileAnnot))
-                lines = ''
+                if "MacroAssembler::" in lines:
+                    signatures.extend(get_normalized_signatures(lines, fileAnnot))
+                lines = ""
                 continue
 
             # We do not aggregate any lines if we are scanning lines which are
             # in-between a set of curly braces.
             if braces_depth > 0:
                 continue
             if was_braces_depth != 0:
-                line = line[line.rfind('}') + 1:]
+                line = line[line.rfind("}") + 1 :]
 
             # This logic is used to remove template instantiation, static
             # variable definitions and function declaration from the next
             # function definition.
-            last_semi_colon = line.rfind(';')
+            last_semi_colon = line.rfind(";")
             if last_semi_colon != -1:
-                lines = ''
-                line = line[last_semi_colon + 1:]
+                lines = ""
+                line = line[last_semi_colon + 1 :]
 
             # Aggregate lines of non-braced text, which corresponds to the space
             # where we are expecting to find function definitions.
             lines = lines + line
 
     return signatures
 
 
 def get_macroassembler_declaration(filename):
     style_section = False
-    lines = ''
+    lines = ""
     signatures = []
     with open(filename) as f:
         for line in f:
-            if '//{{{ check_macroassembler_decl_style' in line:
+            if "//{{{ check_macroassembler_decl_style" in line:
                 style_section = True
-            elif '//}}} check_macroassembler_decl_style' in line:
+            elif "//}}} check_macroassembler_decl_style" in line:
                 style_section = False
             if not style_section:
                 continue
 
             # Ignore preprocessor directives.
-            if line.startswith('#'):
+            if line.startswith("#"):
                 continue
 
-            line = re.sub(r'//.*', '', line)
-            if len(line.strip()) == 0 or 'public:' in line or 'private:' in line:
-                lines = ''
+            line = re.sub(r"//.*", "", line)
+            if len(line.strip()) == 0 or "public:" in line or "private:" in line:
+                lines = ""
                 continue
 
             lines = lines + line
 
             # Continue until we have a complete declaration
-            if ';' not in lines:
+            if ";" not in lines:
                 continue
 
             # Skip member declarations: which are lines ending with a
             # semi-colon without any list of arguments.
-            if ')' not in lines:
-                lines = ''
+            if ")" not in lines:
+                lines = ""
                 continue
 
             signatures.extend(get_normalized_signatures(lines))
-            lines = ''
+            lines = ""
 
     return signatures
 
 
 def append_signatures(d, sigs):
     for s in sigs:
-        if s['sig'] not in d:
-            d[s['sig']] = []
-        d[s['sig']].append(s['arch'])
+        if s["sig"] not in d:
+            d[s["sig"]] = []
+        d[s["sig"]].append(s["arch"])
     return d
 
 
 def generate_file_content(signatures):
     output = []
     for s in sorted(signatures.keys()):
         archs = set(sorted(signatures[s]))
         archs -= all_unsupported_architectures_names
         if len(archs.symmetric_difference(architecture_independent)) == 0:
-            output.append(s + ';\n')
-            if s.startswith('inline'):
+            output.append(s + ";\n")
+            if s.startswith("inline"):
                 # TODO, bug 1432600: This is mistaken for OOL_IN_HEADER
                 # functions.  (Such annotation is already removed by the time
                 # this function sees the signature here.)
-                output.append('    is defined in MacroAssembler-inl.h\n')
+                output.append("    is defined in MacroAssembler-inl.h\n")
             else:
-                output.append('    is defined in MacroAssembler.cpp\n')
+                output.append("    is defined in MacroAssembler.cpp\n")
         else:
             if len(archs.symmetric_difference(all_architecture_names)) == 0:
-                output.append(s + ' PER_ARCH;\n')
+                output.append(s + " PER_ARCH;\n")
             elif len(archs.symmetric_difference(all_shared_architecture_names)) == 0:
-                output.append(s + ' PER_SHARED_ARCH;\n')
+                output.append(s + " PER_SHARED_ARCH;\n")
             else:
-                output.append(
-                    s + ' DEFINED_ON(' + ', '.join(sorted(archs)) + ');\n')
+                output.append(s + " DEFINED_ON(" + ", ".join(sorted(archs)) + ");\n")
             for a in sorted(archs):
-                a = a.replace('_', '-')
-                masm = '%s/MacroAssembler-%s' % (a, a)
-                if s.startswith('inline'):
-                    output.append('    is defined in %s-inl.h\n' % masm)
+                a = a.replace("_", "-")
+                masm = "%s/MacroAssembler-%s" % (a, a)
+                if s.startswith("inline"):
+                    output.append("    is defined in %s-inl.h\n" % masm)
                 else:
-                    output.append('    is defined in %s.cpp\n' % masm)
+                    output.append("    is defined in %s.cpp\n" % masm)
     return output
 
 
 def check_style():
     # We read from the header file the signature of each function.
-    decls = dict()      # type: dict(signature => ['x86', 'x64'])
+    decls = dict()  # type: dict(signature => ['x86', 'x64'])
 
     # We infer from each file the signature of each MacroAssembler function.
-    defs = dict()       # type: dict(signature => ['x86', 'x64'])
+    defs = dict()  # type: dict(signature => ['x86', 'x64'])
 
-    root_dir = os.path.join('js', 'src', 'jit')
+    root_dir = os.path.join("js", "src", "jit")
     for dirpath, dirnames, filenames in os.walk(root_dir):
         for filename in filenames:
-            if 'MacroAssembler' not in filename:
+            if "MacroAssembler" not in filename:
                 continue
 
-            filepath = os.path.join(dirpath, filename).replace('\\', '/')
+            filepath = os.path.join(dirpath, filename).replace("\\", "/")
 
-            if filepath.endswith('MacroAssembler.h'):
+            if filepath.endswith("MacroAssembler.h"):
                 decls = append_signatures(
-                    decls, get_macroassembler_declaration(filepath))
-            defs = append_signatures(
-                defs, get_macroassembler_definitions(filepath))
+                    decls, get_macroassembler_declaration(filepath)
+                )
+            defs = append_signatures(defs, get_macroassembler_definitions(filepath))
 
     if not decls or not defs:
         raise Exception("Did not find any definitions or declarations")
 
     # Compare declarations and definitions output.
-    difflines = difflib.unified_diff(generate_file_content(decls),
-                                     generate_file_content(defs),
-                                     fromfile='check_macroassembler_style.py declared syntax',
-                                     tofile='check_macroassembler_style.py found definitions')
+    difflines = difflib.unified_diff(
+        generate_file_content(decls),
+        generate_file_content(defs),
+        fromfile="check_macroassembler_style.py declared syntax",
+        tofile="check_macroassembler_style.py found definitions",
+    )
     ok = True
     for diffline in difflines:
         ok = False
-        print(diffline, end='')
+        print(diffline, end="")
 
     return ok
 
 
 def main():
     ok = check_style()
 
     if ok:
-        print('TEST-PASS | check_macroassembler_style.py | ok')
+        print("TEST-PASS | check_macroassembler_style.py | ok")
     else:
-        print('TEST-UNEXPECTED-FAIL | check_macroassembler_style.py | actual output does not match expected output;  diff is above')  # noqa: E501
+        print(
+            "TEST-UNEXPECTED-FAIL | check_macroassembler_style.py | actual output does not match expected output;  diff is above"  # noqa: E501
+        )
 
     sys.exit(0 if ok else 1)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

--- a/js/src/devtools/rootAnalysis/t/testlib.py
+++ b/js/src/devtools/rootAnalysis/t/testlib.py
@@ -3,93 +3,106 @@ import os
 import re
 import subprocess
 
 from sixgill import Body
 from collections import defaultdict, namedtuple
 
 scriptdir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 
-HazardSummary = namedtuple('HazardSummary', [
-    'function',
-    'variable',
-    'type',
-    'GCFunction',
-    'location'])
+HazardSummary = namedtuple(
+    "HazardSummary", ["function", "variable", "type", "GCFunction", "location"]
+)
 
-Callgraph = namedtuple('Callgraph', [
-    'functionNames',
-    'nameToId',
-    'mangledToUnmangled',
-    'unmangledToMangled',
-    'calleesOf',
-    'callersOf',
-    'tags',
-    'calleeGraph',
-    'callerGraph'])
+Callgraph = namedtuple(
+    "Callgraph",
+    [
+        "functionNames",
+        "nameToId",
+        "mangledToUnmangled",
+        "unmangledToMangled",
+        "calleesOf",
+        "callersOf",
+        "tags",
+        "calleeGraph",
+        "callerGraph",
+    ],
+)
 
 
 def equal(got, expected):
     if got != expected:
         print("Got '%s', expected '%s'" % (got, expected))
 
 
 def extract_unmangled(func):
-    return func.split('$')[-1]
+    return func.split("$")[-1]
 
 
 class Test(object):
     def __init__(self, indir, outdir, cfg, verbose=0):
         self.indir = indir
         self.outdir = outdir
         self.cfg = cfg
         self.verbose = verbose
 
     def infile(self, path):
         return os.path.join(self.indir, path)
 
     def binpath(self, prog):
         return os.path.join(self.cfg.sixgill_bin, prog)
 
-    def compile(self, source, options=''):
+    def compile(self, source, options=""):
         env = os.environ
-        env['CCACHE_DISABLE'] = '1'
+        env["CCACHE_DISABLE"] = "1"
         cmd = "{CXX} -c {source} -O3 -std=c++11 -fplugin={sixgill} -fplugin-arg-xgill-mangle=1 {options}".format(  # NOQA: E501
             source=self.infile(source),
-            CXX=self.cfg.cxx, sixgill=self.cfg.sixgill_plugin,
-            options=options)
+            CXX=self.cfg.cxx,
+            sixgill=self.cfg.sixgill_plugin,
+            options=options,
+        )
         if self.cfg.verbose:
             print("Running %s" % cmd)
         subprocess.check_call(["sh", "-c", cmd])
 
     def load_db_entry(self, dbname, pattern):
-        '''Look up an entry from an XDB database file, 'pattern' may be an exact
-        matching string, or an re pattern object matching a single entry.'''
+        """Look up an entry from an XDB database file, 'pattern' may be an exact
+        matching string, or an re pattern object matching a single entry."""
 
-        if hasattr(pattern, 'match'):
-            output = subprocess.check_output([self.binpath("xdbkeys"), dbname + ".xdb"],
-                                             universal_newlines=True)
+        if hasattr(pattern, "match"):
+            output = subprocess.check_output(
+                [self.binpath("xdbkeys"), dbname + ".xdb"], universal_newlines=True
+            )
             matches = list(filter(lambda _: re.search(pattern, _), output.splitlines()))
             if len(matches) == 0:
                 raise Exception("entry not found")
             if len(matches) > 1:
                 raise Exception("multiple entries found")
             pattern = matches[0]
 
-        output = subprocess.check_output([self.binpath("xdbfind"), "-json", dbname + ".xdb",
-                                          pattern],
-                                         universal_newlines=True)
+        output = subprocess.check_output(
+            [self.binpath("xdbfind"), "-json", dbname + ".xdb", pattern],
+            universal_newlines=True,
+        )
         return json.loads(output)
 
     def run_analysis_script(self, phase, upto=None):
-        open("defaults.py", "w").write('''\
+        open("defaults.py", "w").write(
+            """\
 analysis_scriptdir = '{scriptdir}'
 sixgill_bin = '{bindir}'
-'''.format(scriptdir=scriptdir, bindir=self.cfg.sixgill_bin))
-        cmd = [os.path.join(scriptdir, "analyze.py"), '-v' if self.verbose else '-q', phase]
+""".format(
+                scriptdir=scriptdir, bindir=self.cfg.sixgill_bin
+            )
+        )
+        cmd = [
+            os.path.join(scriptdir, "analyze.py"),
+            "-v" if self.verbose else "-q",
+            phase,
+        ]
         if upto:
             cmd += ["--upto", upto]
         cmd.append("--source=%s" % self.indir)
         cmd.append("--objdir=%s" % self.outdir)
         cmd.append("--js=%s" % self.cfg.js)
         if self.cfg.verbose:
             cmd.append("--verbose")
             print("Running " + " ".join(cmd))
@@ -102,40 +115,46 @@ sixgill_bin = '{bindir}'
         self.run_analysis_script("gcTypes")
 
     def load_text_file(self, filename, extract=lambda l: l):
         fullpath = os.path.join(self.outdir, filename)
         values = (extract(line.strip()) for line in open(fullpath, "r"))
         return list(filter(lambda _: _ is not None, values))
 
     def load_suppressed_functions(self):
-        return set(self.load_text_file("limitedFunctions.lst", extract=lambda l: l.split(' ')[1]))
+        return set(
+            self.load_text_file(
+                "limitedFunctions.lst", extract=lambda l: l.split(" ")[1]
+            )
+        )
 
     def load_gcTypes(self):
         def grab_type(line):
-            m = re.match(r'^(GC\w+): (.*)', line)
+            m = re.match(r"^(GC\w+): (.*)", line)
             if m:
-                return (m.group(1) + 's', m.group(2))
+                return (m.group(1) + "s", m.group(2))
             return None
 
         gctypes = defaultdict(list)
-        for collection, typename in self.load_text_file('gcTypes.txt', extract=grab_type):
+        for collection, typename in self.load_text_file(
+            "gcTypes.txt", extract=grab_type
+        ):
             gctypes[collection].append(typename)
         return gctypes
 
     def load_typeInfo(self, filename="typeInfo.txt"):
         with open(os.path.join(self.outdir, filename)) as fh:
             return json.load(fh)
 
     def load_gcFunctions(self):
-        return self.load_text_file('gcFunctions.lst', extract=extract_unmangled)
+        return self.load_text_file("gcFunctions.lst", extract=extract_unmangled)
 
     def load_callgraph(self):
         data = Callgraph(
-            functionNames=['dummy'],
+            functionNames=["dummy"],
             nameToId={},
             mangledToUnmangled={},
             unmangledToMangled={},
             calleesOf=defaultdict(list),
             callersOf=defaultdict(list),
             tags=defaultdict(set),
             calleeGraph=defaultdict(dict),
             callerGraph=defaultdict(dict),
@@ -147,64 +166,66 @@ sixgill_bin = '{bindir}'
 
         def add_call(caller, callee, limit):
             data.calleesOf[caller].append(callee)
             data.callersOf[callee].append(caller)
             data.calleeGraph[caller][callee] = True
             data.callerGraph[callee][caller] = True
 
         def process(line):
-            if line.startswith('#'):
+            if line.startswith("#"):
                 name = line.split(" ", 1)[1]
                 data.nameToId[name] = len(data.functionNames)
                 data.functionNames.append(name)
                 return
 
-            if line.startswith('='):
-                m = re.match(r'^= (\d+) (.*)', line)
+            if line.startswith("="):
+                m = re.match(r"^= (\d+) (.*)", line)
                 mangled = data.functionNames[int(m.group(1))]
                 unmangled = m.group(2)
                 data.nameToId[unmangled] = id
                 data.mangledToUnmangled[mangled] = unmangled
                 data.unmangledToMangled[unmangled] = mangled
                 return
 
             limit = 0
-            m = re.match(r'^\w (?:/(\d+))? ', line)
+            m = re.match(r"^\w (?:/(\d+))? ", line)
             if m:
                 limit = int(m[1])
 
-            tokens = line.split(' ')
-            if tokens[0] in ('D', 'R'):
+            tokens = line.split(" ")
+            if tokens[0] in ("D", "R"):
                 _, caller, callee = tokens
                 add_call(lookup(caller), lookup(callee), limit)
-            elif tokens[0] == 'T':
-                data.tags[tokens[1]].add(line.split(' ', 2)[2])
-            elif tokens[0] in ('F', 'V'):
-                m = re.match(r'^[FV] (\d+) (\d+) CLASS (.*?) FIELD (.*)', line)
+            elif tokens[0] == "T":
+                data.tags[tokens[1]].add(line.split(" ", 2)[2])
+            elif tokens[0] in ("F", "V"):
+                m = re.match(r"^[FV] (\d+) (\d+) CLASS (.*?) FIELD (.*)", line)
                 caller, callee, csu, field = m.groups()
                 add_call(lookup(caller), lookup(callee), limit)
 
-            elif tokens[0] == 'I':
-                m = re.match(r'^I (\d+) VARIABLE ([^\,]*)', line)
+            elif tokens[0] == "I":
+                m = re.match(r"^I (\d+) VARIABLE ([^\,]*)", line)
                 pass
 
-        self.load_text_file('callgraph.txt', extract=process)
+        self.load_text_file("callgraph.txt", extract=process)
         return data
 
     def load_hazards(self):
         def grab_hazard(line):
             m = re.match(
-                r"Function '(.*?)' has unrooted '(.*?)' of type '(.*?)' live across GC call '(.*?)' at (.*)", line)  # NOQA: E501
+                r"Function '(.*?)' has unrooted '(.*?)' of type '(.*?)' live across GC call '(.*?)' at (.*)",  # NOQA: E501
+                line,
+            )
             if m:
                 info = list(m.groups())
                 info[0] = info[0].split("$")[-1]
                 info[3] = info[3].split("$")[-1]
                 return HazardSummary(*info)
             return None
 
-        return self.load_text_file('rootingHazards.txt', extract=grab_hazard)
+        return self.load_text_file("rootingHazards.txt", extract=grab_hazard)
 
     def process_body(self, body):
         return Body(body)
 
     def process_bodies(self, bodies):
         return [self.process_body(b) for b in bodies]

--- a/js/src/util/make_unicode.py
+++ b/js/src/util/make_unicode.py
@@ -30,63 +30,66 @@ from contextlib import closing
 from functools import partial
 from itertools import chain, tee
 from operator import is_not, itemgetter
 from zipfile import ZipFile
 
 if sys.version_info.major == 2:
     from itertools import ifilter as filter, imap as map, izip_longest as zip_longest
     from urllib2 import urlopen
+
     range = xrange
 else:
     from itertools import zip_longest
     from urllib.request import urlopen
 
 
 class codepoint_dict(dict):
     def name(self, code_point):
         (_, _, name, alias) = self[code_point]
-        return '{}{}'.format(name, (' (' + alias + ')' if alias else ''))
+        return "{}{}".format(name, (" (" + alias + ")" if alias else ""))
 
     def full_name(self, code_point):
         (_, _, name, alias) = self[code_point]
-        return 'U+{:04X} {}{}'.format(code_point, name, (' (' + alias + ')' if alias else ''))
+        return "U+{:04X} {}{}".format(
+            code_point, name, (" (" + alias + ")" if alias else "")
+        )
 
 
 # ECMAScript 2016
 # §11.2 White Space
 whitespace = [
     # python doesn't support using control character names :(
     0x9,  # CHARACTER TABULATION
-    0xb,  # LINE TABULATION
-    0xc,  # FORM FEED
-    ord(u'\N{SPACE}'),
-    ord(u'\N{NO-BREAK SPACE}'),
-    ord(u'\N{ZERO WIDTH NO-BREAK SPACE}'),  # also BOM
+    0xB,  # LINE TABULATION
+    0xC,  # FORM FEED
+    ord("\N{SPACE}"),
+    ord("\N{NO-BREAK SPACE}"),
+    ord("\N{ZERO WIDTH NO-BREAK SPACE}"),  # also BOM
 ]
 
 # §11.3 Line Terminators
 line_terminator = [
-    0xa,  # LINE FEED
-    0xd,  # CARRIAGE RETURN
-    ord(u'\N{LINE SEPARATOR}'),
-    ord(u'\N{PARAGRAPH SEPARATOR}'),
+    0xA,  # LINE FEED
+    0xD,  # CARRIAGE RETURN
+    ord("\N{LINE SEPARATOR}"),
+    ord("\N{PARAGRAPH SEPARATOR}"),
 ]
 
 # These are also part of IdentifierPart §11.6 Names and Keywords
 compatibility_identifier_part = [
-    ord(u'\N{ZERO WIDTH NON-JOINER}'),
-    ord(u'\N{ZERO WIDTH JOINER}'),
+    ord("\N{ZERO WIDTH NON-JOINER}"),
+    ord("\N{ZERO WIDTH JOINER}"),
 ]
 
 FLAG_SPACE = 1 << 0
 FLAG_UNICODE_ID_START = 1 << 1
 FLAG_UNICODE_ID_CONTINUE_ONLY = 1 << 2
 
-MAX_BMP = 0xffff
+MAX_BMP = 0xFFFF
 
 public_domain = """
 /*
  * Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/licenses/publicdomain/
  */
 """
 
@@ -104,94 +107,93 @@ warning_message = """\
 
 unicode_version_message = """\
 /* Unicode version: {0} */
 """
 
 
 def read_unicode_data(unicode_data):
     """
-        If you want to understand how this wonderful file format works checkout
-          Unicode Standard Annex #44 - Unicode Character Database
-          http://www.unicode.org/reports/tr44/
+    If you want to understand how this wonderful file format works checkout
+      Unicode Standard Annex #44 - Unicode Character Database
+      http://www.unicode.org/reports/tr44/
     """
 
-    reader = csv.reader(unicode_data, delimiter=str(';'))
+    reader = csv.reader(unicode_data, delimiter=str(";"))
 
     while True:
         row = next(reader, None)
         if row is None:
             return
         name = row[1]
 
         # We need to expand the UAX #44 4.2.3 Code Point Range
-        if name.startswith('<') and name.endswith('First>'):
+        if name.startswith("<") and name.endswith("First>"):
             next_row = next(reader)
 
             for i in range(int(row[0], 16), int(next_row[0], 16) + 1):
                 row[0] = i
                 row[1] = name[1:-8]
 
                 yield row
         else:
             row[0] = int(row[0], 16)
             yield row
 
 
 def read_case_folding(case_folding):
     """
-        File format is:
-        <code>; <status>; <mapping>; # <name>
+    File format is:
+    <code>; <status>; <mapping>; # <name>
     """
 
     for line in case_folding:
-        if line == '\n' or line.startswith('#'):
+        if line == "\n" or line.startswith("#"):
             continue
-        row = line.split('; ')
-        if row[1] in ['F', 'T']:
+        row = line.split("; ")
+        if row[1] in ["F", "T"]:
             continue
-        assert row[1] in ['C', 'S'],\
-               "expect either (C)ommon or (S)imple case foldings"
+        assert row[1] in ["C", "S"], "expect either (C)ommon or (S)imple case foldings"
         code = int(row[0], 16)
         mapping = int(row[2], 16)
         yield (code, mapping)
 
 
 def read_derived_core_properties(derived_core_properties):
     for line in derived_core_properties:
-        if line == '\n' or line.startswith('#'):
+        if line == "\n" or line.startswith("#"):
             continue
-        row = line.split('#')[0].split(';')
+        row = line.split("#")[0].split(";")
         char_range = row[0].strip()
         char_property = row[1].strip()
-        if '..' not in char_range:
+        if ".." not in char_range:
             yield (int(char_range, 16), char_property)
         else:
-            [start, end] = char_range.split('..')
+            [start, end] = char_range.split("..")
             for char in range(int(start, 16), int(end, 16) + 1):
                 yield (char, char_property)
 
 
 def read_special_casing(special_casing):
     # Format:
     # <code>; <lower>; <title>; <upper>; (<condition_list>;)? # <comment>
     for line in special_casing:
-        if line == '\n' or line.startswith('#'):
+        if line == "\n" or line.startswith("#"):
             continue
-        row = line.split('#')[0].split(';')
+        row = line.split("#")[0].split(";")
         code = int(row[0].strip(), 16)
         lower = row[1].strip()
-        lower = [int(c, 16) for c in lower.split(' ')] if lower else []
+        lower = [int(c, 16) for c in lower.split(" ")] if lower else []
         upper = row[3].strip()
-        upper = [int(c, 16) for c in upper.split(' ')] if upper else []
+        upper = [int(c, 16) for c in upper.split(" ")] if upper else []
         languages = []
         contexts = []
         condition = row[4].strip()
         if condition:
-            for cond in condition.split(' '):
+            for cond in condition.split(" "):
                 if cond[0].islower():
                     languages.append(cond)
                 else:
                     contexts.append(cond)
             pass
         yield (code, lower, upper, languages, contexts)
 
 
@@ -220,62 +222,72 @@ def make_non_bmp_convert_macro(out_file,
     # Find continuous range in convert_map.
     convert_list = []
     entry = None
     for code in sorted(convert_map.keys()):
         lead, trail = utf16_encode(code)
         converted = convert_map[code]
         diff = converted - code
 
-        if (entry and code == entry['code'] + entry['length'] and
-                diff == entry['diff'] and lead == entry['lead']):
-            entry['length'] += 1
+        if (
+            entry
+            and code == entry["code"] + entry["length"]
+            and diff == entry["diff"]
+            and lead == entry["lead"]
+        ):
+            entry["length"] += 1
             continue
 
         entry = {
-            'code': code,
-            'diff': diff,
-            'length': 1,
-            'lead': lead,
-            'trail': trail,
+            "code": code,
+            "diff": diff,
+            "length": 1,
+            "lead": lead,
+            "trail": trail,
         }
         convert_list.append(entry)
 
     # Generate macro call for each range.
     lines = []
     comment = []
     for entry in convert_list:
-        from_code = entry['code']
-        to_code = entry['code'] + entry['length'] - 1
-        diff = entry['diff']
+        from_code = entry["code"]
+        to_code = entry["code"] + entry["length"] - 1
+        diff = entry["diff"]
 
-        lead = entry['lead']
-        from_trail = entry['trail']
-        to_trail = entry['trail'] + entry['length'] - 1
+        lead = entry["lead"]
+        from_trail = entry["trail"]
+        to_trail = entry["trail"] + entry["length"] - 1
 
-        lines.append('    MACRO(0x{:x}, 0x{:x}, 0x{:x}, 0x{:x}, 0x{:x}, {:d})'.format(
-            from_code, to_code, lead, from_trail, to_trail, diff))
-        comment.append('// {} .. {}'.format(codepoint_table.full_name(from_code),
-                                            codepoint_table.full_name(to_code)))
+        lines.append(
+            "    MACRO(0x{:x}, 0x{:x}, 0x{:x}, 0x{:x}, 0x{:x}, {:d})".format(
+                from_code, to_code, lead, from_trail, to_trail, diff
+            )
+        )
+        comment.append(
+            "// {} .. {}".format(
+                codepoint_table.full_name(from_code), codepoint_table.full_name(to_code)
+            )
+        )
 
-    out_file.write('\n'.join(comment))
-    out_file.write('\n')
-    out_file.write('#define FOR_EACH_NON_BMP_{}(MACRO) \\\n'.format(name))
-    out_file.write(' \\\n'.join(lines))
-    out_file.write('\n')
+    out_file.write("\n".join(comment))
+    out_file.write("\n")
+    out_file.write("#define FOR_EACH_NON_BMP_{}(MACRO) \\\n".format(name))
+    out_file.write(" \\\n".join(lines))
+    out_file.write("\n")
 
 
 def process_derived_core_properties(derived_core_properties):
     id_start = set()
     id_continue = set()
 
     for (char, prop) in read_derived_core_properties(derived_core_properties):
-        if prop == 'ID_Start':
+        if prop == "ID_Start":
             id_start.add(char)
-        if prop == 'ID_Continue':
+        if prop == "ID_Continue":
             id_continue.add(char)
 
     return (id_start, id_continue)
 
 
 def process_unicode_data(unicode_data, derived_core_properties):
     dummy = (0, 0, 0)
     table = [dummy]
@@ -313,31 +325,31 @@ def process_unicode_data(unicode_data, d
 
         codepoint_table[code] = (upper, lower, name, alias)
 
         if code > MAX_BMP:
             if code != lower:
                 non_bmp_lower_map[code] = lower
             if code != upper:
                 non_bmp_upper_map[code] = upper
-            if category == 'Zs':
+            if category == "Zs":
                 non_bmp_space_set[code] = 1
                 test_space_table.append(code)
             if code in id_start:
                 non_bmp_id_start_set[code] = 1
             if code in id_continue:
                 non_bmp_id_cont_set[code] = 1
             continue
 
         assert lower <= MAX_BMP and upper <= MAX_BMP
 
         flags = 0
 
         # we combine whitespace and lineterminators because in pratice we don't need them separated
-        if category == 'Zs' or code in whitespace or code in line_terminator:
+        if category == "Zs" or code in whitespace or code in line_terminator:
             flags |= FLAG_SPACE
             test_space_table.append(code)
 
         # §11.6 (IdentifierStart)
         if code in id_start:
             flags |= FLAG_UNICODE_ID_START
 
         # §11.6 (IdentifierPart)
@@ -345,34 +357,38 @@ def process_unicode_data(unicode_data, d
             flags |= FLAG_UNICODE_ID_CONTINUE_ONLY
 
         up_d = upper - code
         low_d = lower - code
 
         assert up_d > -65535 and up_d < 65535
         assert low_d > -65535 and low_d < 65535
 
-        upper = up_d & 0xffff
-        lower = low_d & 0xffff
+        upper = up_d & 0xFFFF
+        lower = low_d & 0xFFFF
 
         item = (upper, lower, flags)
 
         i = cache.get(item)
         if i is None:
             assert item not in table
             cache[item] = i = len(table)
             table.append(item)
         index[code] = i
 
     return (
-        table, index,
-        non_bmp_lower_map, non_bmp_upper_map,
+        table,
+        index,
+        non_bmp_lower_map,
+        non_bmp_upper_map,
         non_bmp_space_set,
-        non_bmp_id_start_set, non_bmp_id_cont_set,
-        codepoint_table, test_space_table,
+        non_bmp_id_start_set,
+        non_bmp_id_cont_set,
+        codepoint_table,
+        test_space_table,
     )
 
 
 def process_case_folding(case_folding):
     folding_map = {}
     rev_folding_map = {}
     folding_dummy = (0,)
     folding_table = [folding_dummy]
@@ -414,30 +430,27 @@ def process_case_folding(case_folding):
 
         if code > MAX_BMP:
             continue
 
         folding_d = folding - code
 
         assert folding_d > -65535 and folding_d < 65535
 
-        folding = folding_d & 0xffff
+        folding = folding_d & 0xFFFF
 
         item = (folding,)
 
         i = folding_cache.get(item)
         if i is None:
             assert item not in folding_table
             folding_cache[item] = i = len(folding_table)
             folding_table.append(item)
         folding_index[code] = i
-    return (
-        folding_table, folding_index,
-        folding_tests
-    )
+    return (folding_table, folding_index, folding_tests)
 
 
 def process_special_casing(special_casing, table, index):
     # Unconditional special casing.
     unconditional_tolower = {}
     unconditional_toupper = {}
 
     # Conditional special casing, language independent.
@@ -445,22 +458,26 @@ def process_special_casing(special_casin
     conditional_toupper = {}
 
     # Conditional special casing, language dependent.
     lang_conditional_tolower = {}
     lang_conditional_toupper = {}
 
     def caseInfo(code):
         (upper, lower, flags) = table[index[code]]
-        return ((code + lower) & 0xffff, (code + upper) & 0xffff)
+        return ((code + lower) & 0xFFFF, (code + upper) & 0xFFFF)
 
-    for (code, lower, upper, languages, contexts) in read_special_casing(special_casing):
-        assert code <= MAX_BMP, 'Unexpected character outside of BMP: %s' % code
-        assert len(languages) <= 1, 'Expected zero or one language ids: %s' % languages
-        assert len(contexts) <= 1, 'Expected zero or one casing contexts: %s' % languages
+    for (code, lower, upper, languages, contexts) in read_special_casing(
+        special_casing
+    ):
+        assert code <= MAX_BMP, "Unexpected character outside of BMP: %s" % code
+        assert len(languages) <= 1, "Expected zero or one language ids: %s" % languages
+        assert len(contexts) <= 1, (
+            "Expected zero or one casing contexts: %s" % languages
+        )
 
         (default_lower, default_upper) = caseInfo(code)
         special_lower = len(lower) != 1 or lower[0] != default_lower
         special_upper = len(upper) != 1 or upper[0] != default_upper
 
         # Invariant: If |code| has casing per UnicodeData.txt, then it also has
         # casing rules in SpecialCasing.txt.
         assert code == default_lower or len(lower) != 1 or code != lower[0]
@@ -494,20 +511,20 @@ def process_special_casing(special_casin
         (lower, _) = caseInfo(code)
         return lower
 
     def upperCase(code):
         (_, upper) = caseInfo(code)
         return upper
 
     def ascii(char_dict):
-        return (ch for ch in char_dict.keys() if ch <= 0x7f)
+        return (ch for ch in char_dict.keys() if ch <= 0x7F)
 
     def latin1(char_dict):
-        return (ch for ch in char_dict.keys() if ch <= 0xff)
+        return (ch for ch in char_dict.keys() if ch <= 0xFF)
 
     def is_empty(iterable):
         return not any(True for _ in iterable)
 
     def is_equals(iter1, iter2):
         return all(x == y for (x, y) in zip_longest(iter1, iter2))
 
     # Ensure no ASCII characters have special case mappings.
@@ -538,185 +555,240 @@ def process_special_casing(special_casin
     # Verify U+0130 and U+03A3 have simple lower case mappings.
     assert all(ch != lowerCase(ch) for ch in [0x0130, 0x03A3])
 
     # Ensure Azeri, Lithuanian, and Turkish are the only languages with conditional case mappings.
     assert is_equals(["az", "lt", "tr"], sorted(lang_conditional_tolower.keys()))
     assert is_equals(["az", "lt", "tr"], sorted(lang_conditional_toupper.keys()))
 
     # Maximum case mapping length is three characters.
-    assert max(map(len, chain(
-        unconditional_tolower.values(),
-        unconditional_toupper.values(),
-        map(itemgetter(0), conditional_tolower.values()),
-        map(itemgetter(0), conditional_toupper.values()),
-        map(itemgetter(0), chain.from_iterable(d.values()
-                                               for d in lang_conditional_tolower.values())),
-        map(itemgetter(0), chain.from_iterable(d.values()
-                                               for d in lang_conditional_toupper.values())),
-    ))) <= 3
+    assert (
+        max(
+            map(
+                len,
+                chain(
+                    unconditional_tolower.values(),
+                    unconditional_toupper.values(),
+                    map(itemgetter(0), conditional_tolower.values()),
+                    map(itemgetter(0), conditional_toupper.values()),
+                    map(
+                        itemgetter(0),
+                        chain.from_iterable(
+                            d.values() for d in lang_conditional_tolower.values()
+                        ),
+                    ),
+                    map(
+                        itemgetter(0),
+                        chain.from_iterable(
+                            d.values() for d in lang_conditional_toupper.values()
+                        ),
+                    ),
+                ),
+            )
+        )
+        <= 3
+    )
 
     # Ensure all case mapping contexts are known (see Unicode 9.0, §3.13 Default Case Algorithms).
-    assert set([
-        'After_I', 'After_Soft_Dotted', 'Final_Sigma', 'More_Above', 'Not_Before_Dot',
-    ]).issuperset(set(filter(partial(is_not, None), chain(
-        map(itemgetter(1), conditional_tolower.values()),
-        map(itemgetter(1), conditional_toupper.values()),
-        map(itemgetter(1), chain.from_iterable(d.values()
-                                               for d in lang_conditional_tolower.values())),
-        map(itemgetter(1), chain.from_iterable(d.values()
-                                               for d in lang_conditional_toupper.values())),
-    ))))
+    assert set(
+        [
+            "After_I",
+            "After_Soft_Dotted",
+            "Final_Sigma",
+            "More_Above",
+            "Not_Before_Dot",
+        ]
+    ).issuperset(
+        set(
+            filter(
+                partial(is_not, None),
+                chain(
+                    map(itemgetter(1), conditional_tolower.values()),
+                    map(itemgetter(1), conditional_toupper.values()),
+                    map(
+                        itemgetter(1),
+                        chain.from_iterable(
+                            d.values() for d in lang_conditional_tolower.values()
+                        ),
+                    ),
+                    map(
+                        itemgetter(1),
+                        chain.from_iterable(
+                            d.values() for d in lang_conditional_toupper.values()
+                        ),
+                    ),
+                ),
+            )
+        )
+    )
 
     # Special casing for U+00DF (LATIN SMALL LETTER SHARP S).
-    assert upperCase(0x00DF) == 0x00DF and unconditional_toupper[0x00DF] == [0x0053, 0x0053]
+    assert upperCase(0x00DF) == 0x00DF and unconditional_toupper[0x00DF] == [
+        0x0053,
+        0x0053,
+    ]
 
     # Special casing for U+0130 (LATIN CAPITAL LETTER I WITH DOT ABOVE).
     assert unconditional_tolower[0x0130] == [0x0069, 0x0307]
 
     # Special casing for U+03A3 (GREEK CAPITAL LETTER SIGMA).
-    assert lowerCase(0x03A3) == 0x03C3 and conditional_tolower[0x03A3] == ([0x03C2], 'Final_Sigma')
+    assert lowerCase(0x03A3) == 0x03C3 and conditional_tolower[0x03A3] == (
+        [0x03C2],
+        "Final_Sigma",
+    )
 
     return (unconditional_tolower, unconditional_toupper)
 
 
-def make_non_bmp_file(version,
-                      non_bmp_lower_map, non_bmp_upper_map,
-                      codepoint_table):
-    file_name = 'UnicodeNonBMP.h'
-    with io.open(file_name, mode='w', encoding='utf-8') as non_bmp_file:
+def make_non_bmp_file(version, non_bmp_lower_map, non_bmp_upper_map, codepoint_table):
+    file_name = "UnicodeNonBMP.h"
+    with io.open(file_name, mode="w", encoding="utf-8") as non_bmp_file:
         non_bmp_file.write(mpl_license)
-        non_bmp_file.write('\n')
+        non_bmp_file.write("\n")
         non_bmp_file.write(warning_message)
         non_bmp_file.write(unicode_version_message.format(version))
-        non_bmp_file.write("""
+        non_bmp_file.write(
+            """
 #ifndef util_UnicodeNonBMP_h
 #define util_UnicodeNonBMP_h
 
 // |MACRO| receives the following arguments
 //   MACRO(FROM, TO, LEAD, TRAIL_FROM, TRAIL_TO, DIFF)
 //     FROM:       code point where the range starts
 //     TO:         code point where the range ends
 //     LEAD:       common lead surrogate of FROM and TO
 //     TRAIL_FROM: trail surrogate of FROM
 //     TRAIL_FROM: trail surrogate of TO
 //     DIFF:       the difference between the code point in the range and
 //                 converted code point
 
-""")
+"""
+        )
 
-        make_non_bmp_convert_macro(non_bmp_file, 'LOWERCASE', non_bmp_lower_map, codepoint_table)
-        non_bmp_file.write('\n')
-        make_non_bmp_convert_macro(non_bmp_file, 'UPPERCASE', non_bmp_upper_map, codepoint_table)
+        make_non_bmp_convert_macro(
+            non_bmp_file, "LOWERCASE", non_bmp_lower_map, codepoint_table
+        )
+        non_bmp_file.write("\n")
+        make_non_bmp_convert_macro(
+            non_bmp_file, "UPPERCASE", non_bmp_upper_map, codepoint_table
+        )
 
-        non_bmp_file.write("""
+        non_bmp_file.write(
+            """
 #endif /* util_UnicodeNonBMP_h */
-""")
+"""
+        )
 
 
 def write_special_casing_methods(unconditional_toupper, codepoint_table, println):
     def hexlit(n):
         """ Returns C++ hex-literal for |n|. """
-        return '0x{:04X}'.format(n)
+        return "0x{:04X}".format(n)
 
     def describe_range(ranges, depth):
-        indent = depth * '    '
+        indent = depth * "    "
         for (start, end) in ranges:
             if start == end:
-                println(indent, '// {}'.format(codepoint_table.full_name(start)))
+                println(indent, "// {}".format(codepoint_table.full_name(start)))
             else:
-                println(indent, '// {} .. {}'.format(codepoint_table.full_name(start),
-                                                     codepoint_table.full_name(end)))
+                println(
+                    indent,
+                    "// {} .. {}".format(
+                        codepoint_table.full_name(start), codepoint_table.full_name(end)
+                    ),
+                )
 
     def out_range(start, end):
         """ Tests if the input character isn't a member of the set {x | start <= x <= end}. """
-        if (start == end):
-            return 'ch != {}'.format(hexlit(start))
-        return 'ch < {} || ch > {}'.format(hexlit(start), hexlit(end))
+        if start == end:
+            return "ch != {}".format(hexlit(start))
+        return "ch < {} || ch > {}".format(hexlit(start), hexlit(end))
 
     def in_range(start, end, parenthesize=False):
         """ Tests if the input character is in the set {x | start <= x <= end}. """
-        if (start == end):
-            return 'ch == {}'.format(hexlit(start))
-        (left, right) = ('(', ')') if parenthesize else ('', '')
-        return '{}ch >= {} && ch <= {}{}'.format(left, hexlit(start), hexlit(end), right)
+        if start == end:
+            return "ch == {}".format(hexlit(start))
+        (left, right) = ("(", ")") if parenthesize else ("", "")
+        return "{}ch >= {} && ch <= {}{}".format(
+            left, hexlit(start), hexlit(end), right
+        )
 
     def in_any_range(ranges, spaces):
         """ Tests if the input character is included in any of the given ranges. """
         lines = [[]]
         for (start, end) in ranges:
             expr = in_range(start, end, parenthesize=True)
-            line = ' || '.join(lines[-1] + [expr])
-            if len(line) < (100 - len(spaces) - len(' ||')):
+            line = " || ".join(lines[-1] + [expr])
+            if len(line) < (100 - len(spaces) - len(" ||")):
                 lines[-1].append(expr)
             else:
                 lines.append([expr])
-        return ' ||\n{}'.format(spaces).join(' || '.join(t) for t in lines)
+        return " ||\n{}".format(spaces).join(" || ".join(t) for t in lines)
 
     def write_range_accept(parent_list, child_list, depth):
         """ Accepts the input character if it matches any code unit in |child_list|. """
         (min_parent, max_parent) = (parent_list[0], parent_list[-1])
         (min_child, max_child) = (child_list[0], child_list[-1])
         assert min_child >= min_parent
         assert max_child <= max_parent
-        indent = depth * '    '
+        indent = depth * "    "
 
         child_ranges = list(int_ranges(child_list))
         has_successor = max_child != max_parent
 
         # If |child_list| is a contiguous list of code units, emit a simple
         # range check: |min_child <= input <= max_child|.
         if len(child_ranges) == 1:
             describe_range(child_ranges, depth)
             if has_successor:
-                println(indent, 'if (ch <= {}) {{'.format(hexlit(max_child)))
-                println(indent, '    return ch >= {};'.format(hexlit(min_child)))
-                println(indent, '}')
+                println(indent, "if (ch <= {}) {{".format(hexlit(max_child)))
+                println(indent, "    return ch >= {};".format(hexlit(min_child)))
+                println(indent, "}")
             else:
-                println(indent, 'return {};'.format(in_range(min_child, max_child)))
+                println(indent, "return {};".format(in_range(min_child, max_child)))
             return
 
         # Otherwise create a disjunction over the subranges in |child_ranges|.
         if not has_successor:
-            spaces = indent + len('return ') * ' '
+            spaces = indent + len("return ") * " "
         else:
-            spaces = indent + len('    return ') * ' '
+            spaces = indent + len("    return ") * " "
         range_test_expr = in_any_range(child_ranges, spaces)
 
         if min_child != min_parent:
-            println(indent, 'if (ch < {}) {{'.format(hexlit(min_child)))
-            println(indent, '    return false;')
-            println(indent, '}')
+            println(indent, "if (ch < {}) {{".format(hexlit(min_child)))
+            println(indent, "    return false;")
+            println(indent, "}")
 
         # If there's no successor block, we can omit the |input <= max_child| check,
         # because it was already checked when we emitted the parent range test.
         if not has_successor:
             describe_range(child_ranges, depth)
-            println(indent, 'return {};'.format(range_test_expr))
+            println(indent, "return {};".format(range_test_expr))
         else:
-            println(indent, 'if (ch <= {}) {{'.format(hexlit(max_child)))
+            println(indent, "if (ch <= {}) {{".format(hexlit(max_child)))
             describe_range(child_ranges, depth + 1)
-            println(indent, '    return {};'.format(range_test_expr))
-            println(indent, '}')
+            println(indent, "    return {};".format(range_test_expr))
+            println(indent, "}")
 
     def write_ChangesWhenUpperCasedSpecialCasing():
         """ Checks if the input has a special upper case mapping. """
-        println('bool')
-        println('js::unicode::ChangesWhenUpperCasedSpecialCasing(char16_t ch)')
-        println('{')
+        println("bool")
+        println("js::unicode::ChangesWhenUpperCasedSpecialCasing(char16_t ch)")
+        println("{")
 
         assert unconditional_toupper, "|unconditional_toupper| is not empty"
 
         # Sorted list of code units with special upper case mappings.
         code_list = sorted(unconditional_toupper.keys())
 
         # Fail-fast if the input character isn't a special casing character.
-        println('    if ({}) {{'.format(out_range(code_list[0], code_list[-1])))
-        println('        return false;')
-        println('    }')
+        println("    if ({}) {{".format(out_range(code_list[0], code_list[-1])))
+        println("        return false;")
+        println("    }")
 
         for i in range(0, 16):
             # Check if the input characters is in the range:
             # |start_point <= input < end_point|.
             start_point = i << 12
             end_point = (i + 1) << 12
             matches = [cu for cu in code_list if start_point <= cu < end_point]
 
@@ -731,271 +803,325 @@ def write_special_casing_methods(uncondi
                 continue
 
             # Otherwise split into further subranges.
 
             # Only enter the if-block if the input is less-or-equals to the
             # largest value in the current range.
             is_last_block = matches[-1] == code_list[-1]
             if not is_last_block:
-                println('    if (ch <= {}) {{'.format(hexlit(matches[-1])))
+                println("    if (ch <= {}) {{".format(hexlit(matches[-1])))
             else:
-                println('    if (ch < {}) {{'.format(hexlit(matches[0])))
-                println('        return false;')
-                println('    }')
+                println("    if (ch < {}) {{".format(hexlit(matches[0])))
+                println("        return false;")
+                println("    }")
 
             for j in range(0, 16):
                 inner_start = start_point + (j << 8)
                 inner_end = start_point + ((j + 1) << 8)
                 inner_matches = [cu for cu in matches if inner_start <= cu < inner_end]
 
                 if inner_matches:
                     d = 1 if is_last_block else 2
                     write_range_accept(matches, inner_matches, depth=d)
 
             if not is_last_block:
-                println('    }')
+                println("    }")
 
-        println('}')
+        println("}")
 
     def write_LengthUpperCaseSpecialCasing():
         """ Slow case: Special casing character was found, returns its mapping length. """
-        println('size_t')
-        println('js::unicode::LengthUpperCaseSpecialCasing(char16_t ch)')
-        println('{')
+        println("size_t")
+        println("js::unicode::LengthUpperCaseSpecialCasing(char16_t ch)")
+        println("{")
 
-        println('    switch(ch) {')
-        for (code, converted) in sorted(unconditional_toupper.items(), key=itemgetter(0)):
-            println('      case {}: return {}; // {}'.format(hexlit(code), len(converted),
-                                                             codepoint_table.name(code)))
-        println('    }')
-        println('')
+        println("    switch(ch) {")
+        for (code, converted) in sorted(
+            unconditional_toupper.items(), key=itemgetter(0)
+        ):
+            println(
+                "      case {}: return {}; // {}".format(
+                    hexlit(code), len(converted), codepoint_table.name(code)
+                )
+            )
+        println("    }")
+        println("")
         println('    MOZ_ASSERT_UNREACHABLE("Bad character input.");')
-        println('    return 0;')
+        println("    return 0;")
 
-        println('}')
+        println("}")
 
     def write_AppendUpperCaseSpecialCasing():
         """ Slow case: Special casing character was found, append its mapping characters. """
-        println('void')
-        println('js::unicode::AppendUpperCaseSpecialCasing(char16_t ch, char16_t* elements, size_t* index)')  # NOQA: E501
-        println('{')
+        println("void")
+        println(
+            "js::unicode::AppendUpperCaseSpecialCasing(char16_t ch, char16_t* elements, size_t* index)"  # NOQA: E501
+        )
+        println("{")
 
-        println('    switch(ch) {')
-        for (code, converted) in sorted(unconditional_toupper.items(), key=itemgetter(0)):
-            println('      case {}: // {}'.format(hexlit(code), codepoint_table.name(code)))
+        println("    switch(ch) {")
+        for (code, converted) in sorted(
+            unconditional_toupper.items(), key=itemgetter(0)
+        ):
+            println(
+                "      case {}: // {}".format(hexlit(code), codepoint_table.name(code))
+            )
             for ch in converted:
-                println('        elements[(*index)++] = {}; // {}'
-                        .format(hexlit(ch),
-                                codepoint_table.name(ch)))
-            println('        return;')
-        println('    }')
-        println('')
+                println(
+                    "        elements[(*index)++] = {}; // {}".format(
+                        hexlit(ch), codepoint_table.name(ch)
+                    )
+                )
+            println("        return;")
+        println("    }")
+        println("")
         println('    MOZ_ASSERT_UNREACHABLE("Bad character input.");')
 
-        println('}')
+        println("}")
 
     write_ChangesWhenUpperCasedSpecialCasing()
-    println('')
+    println("")
     write_LengthUpperCaseSpecialCasing()
-    println('')
+    println("")
     write_AppendUpperCaseSpecialCasing()
 
 
 def write_ascii_lookup_tables(table, index, write, println):
     def is_id_compat(code):
-        return code == ord(u'\N{DOLLAR SIGN}') or code == ord(u'\N{LOW LINE}')
+        return code == ord("\N{DOLLAR SIGN}") or code == ord("\N{LOW LINE}")
 
     def is_id_start(code):
         (upper, lower, flags) = table[index[code]]
         return (flags & FLAG_UNICODE_ID_START) or is_id_compat(code)
 
     def is_id_continue(code):
         (upper, lower, flags) = table[index[code]]
         return (flags & FLAG_UNICODE_ID_CONTINUE_ONLY) or is_id_start(code)
 
     def is_space(code):
         (upper, lower, flags) = table[index[code]]
         return flags & FLAG_SPACE
 
     def write_entries(name, predicate):
-        println('const bool unicode::{}[] = {{'.format(name))
+        println("const bool unicode::{}[] = {{".format(name))
         header = "".join("{0: <6}".format(x) for x in range(0, 10)).rstrip()
-        println('/*       {}  */'.format(header))
+        println("/*       {}  */".format(header))
         for i in range(0, 13):
-            write('/* {0: >2} */'.format(i))
+            write("/* {0: >2} */".format(i))
             for j in range(0, 10):
                 code = i * 10 + j
-                if (code <= 0x7f):
-                    write(' {},'.format('true' if predicate(code) else '____'))
-            println('')
-        println('};')
+                if code <= 0x7F:
+                    write(" {},".format("true" if predicate(code) else "____"))
+            println("")
+        println("};")
 
-    println('')
-    println('#define ____ false')
+    println("")
+    println("#define ____ false")
 
-    println("""
+    println(
+        """
 /*
  * Identifier start chars:
  * -      36:    $
  * -  65..90: A..Z
  * -      95:    _
  * - 97..122: a..z
- */""")
-    write_entries('js_isidstart', is_id_start)
+ */"""
+    )
+    write_entries("js_isidstart", is_id_start)
 
-    println("""
+    println(
+        """
 /*
  * Identifier chars:
  * -      36:    $
  * -  48..57: 0..9
  * -  65..90: A..Z
  * -      95:    _
  * - 97..122: a..z
- */""")
-    write_entries('js_isident', is_id_continue)
+ */"""
+    )
+    write_entries("js_isident", is_id_continue)
 
-    println("""
-/* Whitespace chars: '\\t', '\\n', '\\v', '\\f', '\\r', ' '. */""")
-    write_entries('js_isspace', is_space)
+    println(
+        """
+/* Whitespace chars: '\\t', '\\n', '\\v', '\\f', '\\r', ' '. */"""
+    )
+    write_entries("js_isspace", is_space)
 
-    println('')
-    println('#undef ____')
+    println("")
+    println("#undef ____")
 
 
 def write_latin1_lookup_tables(table, index, write, println):
     def case_info(code):
         assert 0 <= code and code <= MAX_BMP
         (upper, lower, flags) = table[index[code]]
-        return ((code + upper) & 0xffff, (code + lower) & 0xffff, flags)
+        return ((code + upper) & 0xFFFF, (code + lower) & 0xFFFF, flags)
 
     def toLowerCase(code):
         (_, lower, _) = case_info(code)
-        assert lower <= 0xff, "lower-case of Latin-1 is always Latin-1"
+        assert lower <= 0xFF, "lower-case of Latin-1 is always Latin-1"
         return lower
 
     def write_entries(name, mapper):
-        println('const JS::Latin1Char unicode::{}[] = {{'.format(name))
+        println("const JS::Latin1Char unicode::{}[] = {{".format(name))
         header = "".join("{0: <6}".format(x) for x in range(0, 16)).rstrip()
-        println('/*       {}  */'.format(header))
+        println("/*       {}  */".format(header))
         for i in range(0, 16):
-            write('/* {0: >2} */'.format(i))
+            write("/* {0: >2} */".format(i))
             for j in range(0, 16):
                 code = i * 16 + j
-                if (code <= 0xff):
-                    write(' 0x{:02X},'.format(mapper(code)))
-            println('')
-        println('};')
+                if code <= 0xFF:
+                    write(" 0x{:02X},".format(mapper(code)))
+            println("")
+        println("};")
 
-    println('')
-    write_entries('latin1ToLowerCaseTable', toLowerCase)
+    println("")
+    write_entries("latin1ToLowerCaseTable", toLowerCase)
 
 
-def make_bmp_mapping_test(version, codepoint_table, unconditional_tolower, unconditional_toupper):
+def make_bmp_mapping_test(
+    version, codepoint_table, unconditional_tolower, unconditional_toupper
+):
     def unicodeEsc(n):
-        return '\\u{:04X}'.format(n)
+        return "\\u{:04X}".format(n)
 
-    file_name = '../tests/non262/String/string-upper-lower-mapping.js'
-    with io.open(file_name, mode='w', encoding='utf-8') as output:
-        write = partial(print, file=output, sep='', end='')
-        println = partial(print, file=output, sep='', end='\n')
+    file_name = "../tests/non262/String/string-upper-lower-mapping.js"
+    with io.open(file_name, mode="w", encoding="utf-8") as output:
+        write = partial(print, file=output, sep="", end="")
+        println = partial(print, file=output, sep="", end="\n")
 
         write(warning_message)
         write(unicode_version_message.format(version))
         write(public_domain)
-        println('var mapping = [')
+        println("var mapping = [")
         for code in range(0, MAX_BMP + 1):
             entry = codepoint_table.get(code)
 
             if entry:
                 (upper, lower, _, _) = entry
-                upper = unconditional_toupper[code] if code in unconditional_toupper else [upper]
-                lower = unconditional_tolower[code] if code in unconditional_tolower else [lower]
-                println('  ["{}", "{}"], /* {} */'.format("".join(map(unicodeEsc, upper)),
-                                                          "".join(map(unicodeEsc, lower)),
-                                                          codepoint_table.name(code)))
+                upper = (
+                    unconditional_toupper[code]
+                    if code in unconditional_toupper
+                    else [upper]
+                )
+                lower = (
+                    unconditional_tolower[code]
+                    if code in unconditional_tolower
+                    else [lower]
+                )
+                println(
+                    '  ["{}", "{}"], /* {} */'.format(
+                        "".join(map(unicodeEsc, upper)),
+                        "".join(map(unicodeEsc, lower)),
+                        codepoint_table.name(code),
+                    )
+                )
             else:
                 println('  ["{0}", "{0}"],'.format(unicodeEsc(code)))
-        println('];')
-        write("""
+        println("];")
+        write(
+            """
 assertEq(mapping.length, 0x10000);
 for (var i = 0; i <= 0xffff; i++) {
     var char = String.fromCharCode(i);
     var info = mapping[i];
 
     assertEq(char.toUpperCase(), info[0]);
     assertEq(char.toLowerCase(), info[1]);
 }
 
 if (typeof reportCompare === "function")
     reportCompare(true, true);
-""")
+"""
+        )
 
 
-def make_non_bmp_mapping_test(version, non_bmp_upper_map, non_bmp_lower_map, codepoint_table):
-    file_name = '../tests/non262/String/string-code-point-upper-lower-mapping.js'
-    with io.open(file_name, mode='w', encoding='utf-8') as test_non_bmp_mapping:
+def make_non_bmp_mapping_test(
+    version, non_bmp_upper_map, non_bmp_lower_map, codepoint_table
+):
+    file_name = "../tests/non262/String/string-code-point-upper-lower-mapping.js"
+    with io.open(file_name, mode="w", encoding="utf-8") as test_non_bmp_mapping:
         test_non_bmp_mapping.write(warning_message)
         test_non_bmp_mapping.write(unicode_version_message.format(version))
         test_non_bmp_mapping.write(public_domain)
 
         for code in sorted(non_bmp_upper_map.keys()):
-            test_non_bmp_mapping.write("""\
+            test_non_bmp_mapping.write(
+                """\
 assertEq(String.fromCodePoint(0x{:04X}).toUpperCase().codePointAt(0), 0x{:04X}); // {}, {}
-""".format(code, non_bmp_upper_map[code],
-                codepoint_table.name(code), codepoint_table.name(non_bmp_upper_map[code])))
+""".format(
+                    code,
+                    non_bmp_upper_map[code],
+                    codepoint_table.name(code),
+                    codepoint_table.name(non_bmp_upper_map[code]),
+                )
+            )
 
         for code in sorted(non_bmp_lower_map.keys()):
-            test_non_bmp_mapping.write("""\
+            test_non_bmp_mapping.write(
+                """\
 assertEq(String.fromCodePoint(0x{:04X}).toLowerCase().codePointAt(0), 0x{:04X}); // {}, {}
-""".format(code, non_bmp_lower_map[code],
-                codepoint_table.name(code), codepoint_table.name(non_bmp_lower_map[code])))
+""".format(
+                    code,
+                    non_bmp_lower_map[code],
+                    codepoint_table.name(code),
+                    codepoint_table.name(non_bmp_lower_map[code]),
+                )
+            )
 
-        test_non_bmp_mapping.write("""
+        test_non_bmp_mapping.write(
+            """
 if (typeof reportCompare === "function")
     reportCompare(true, true);
-""")
+"""
+        )
 
 
 def make_space_test(version, test_space_table, codepoint_table):
     def hex_and_name(c):
-        return '    0x{:04X} /* {} */'.format(c, codepoint_table.name(c))
+        return "    0x{:04X} /* {} */".format(c, codepoint_table.name(c))
 
-    file_name = '../tests/non262/String/string-space-trim.js'
-    with io.open(file_name, mode='w', encoding='utf-8') as test_space:
+    file_name = "../tests/non262/String/string-space-trim.js"
+    with io.open(file_name, mode="w", encoding="utf-8") as test_space:
         test_space.write(warning_message)
         test_space.write(unicode_version_message.format(version))
         test_space.write(public_domain)
-        test_space.write('var onlySpace = String.fromCharCode(\n')
-        test_space.write(',\n'.join(map(hex_and_name, test_space_table)))
-        test_space.write('\n);\n')
-        test_space.write("""
+        test_space.write("var onlySpace = String.fromCharCode(\n")
+        test_space.write(",\n".join(map(hex_and_name, test_space_table)))
+        test_space.write("\n);\n")
+        test_space.write(
+            """
 assertEq(onlySpace.trim(), "");
 assertEq((onlySpace + 'aaaa').trim(), 'aaaa');
 assertEq(('aaaa' + onlySpace).trim(), 'aaaa');
 assertEq((onlySpace + 'aaaa' + onlySpace).trim(), 'aaaa');
 
 if (typeof reportCompare === "function")
     reportCompare(true, true);
-""")
+"""
+        )
 
 
 def make_regexp_space_test(version, test_space_table, codepoint_table):
     def hex_and_name(c):
-        return '    0x{:04X} /* {} */'.format(c, codepoint_table.name(c))
+        return "    0x{:04X} /* {} */".format(c, codepoint_table.name(c))
 
-    file_name = '../tests/non262/RegExp/character-class-escape-s.js'
-    with io.open(file_name, mode='w', encoding='utf-8') as test_space:
+    file_name = "../tests/non262/RegExp/character-class-escape-s.js"
+    with io.open(file_name, mode="w", encoding="utf-8") as test_space:
         test_space.write(warning_message)
         test_space.write(unicode_version_message.format(version))
         test_space.write(public_domain)
-        test_space.write('var onlySpace = String.fromCodePoint(\n')
-        test_space.write(',\n'.join(map(hex_and_name, test_space_table)))
-        test_space.write('\n);\n')
-        test_space.write("""
+        test_space.write("var onlySpace = String.fromCodePoint(\n")
+        test_space.write(",\n".join(map(hex_and_name, test_space_table)))
+        test_space.write("\n);\n")
+        test_space.write(
+            """
 assertEq(/^\s+$/.exec(onlySpace) !== null, true);
 assertEq(/^[\s]+$/.exec(onlySpace) !== null, true);
 assertEq(/^[^\s]+$/.exec(onlySpace) === null, true);
 
 assertEq(/^\S+$/.exec(onlySpace) === null, true);
 assertEq(/^[\S]+$/.exec(onlySpace) === null, true);
 assertEq(/^[^\S]+$/.exec(onlySpace) !== null, true);
 
@@ -1005,59 +1131,72 @@ assertEq(/^[\s]+$/u.exec(onlySpace) !== 
 assertEq(/^[^\s]+$/u.exec(onlySpace) === null, true);
 
 assertEq(/^\S+$/u.exec(onlySpace) === null, true);
 assertEq(/^[\S]+$/u.exec(onlySpace) === null, true);
 assertEq(/^[^\S]+$/u.exec(onlySpace) !== null, true);
 
 if (typeof reportCompare === "function")
     reportCompare(true, true);
-""")
+"""
+        )
 
 
 def make_icase_test(version, folding_tests, codepoint_table):
     def char_hex(c):
-        return '0x{:04X}'.format(c)
+        return "0x{:04X}".format(c)
 
-    file_name = '../tests/non262/RegExp/unicode-ignoreCase.js'
-    with io.open(file_name, mode='w', encoding='utf-8') as test_icase:
+    file_name = "../tests/non262/RegExp/unicode-ignoreCase.js"
+    with io.open(file_name, mode="w", encoding="utf-8") as test_icase:
         test_icase.write(warning_message)
         test_icase.write(unicode_version_message.format(version))
         test_icase.write(public_domain)
-        test_icase.write("""
+        test_icase.write(
+            """
 var BUGNUMBER = 1135377;
 var summary = "Implement RegExp unicode flag -- ignoreCase flag.";
 
 print(BUGNUMBER + ": " + summary);
 
 function test(code, ...equivs) {
   var codeRe = new RegExp(String.fromCodePoint(code) + "+", "iu");
   var ans = String.fromCodePoint(code) + equivs.map(c => String.fromCodePoint(c)).join("");
   assertEqArray(codeRe.exec("<" + ans + ">"), [ans]);
   codeRe = new RegExp("[" + String.fromCodePoint(code) + "]+", "iu");
   assertEqArray(codeRe.exec("<" + ans + ">"), [ans]);
 }
-""")
+"""
+        )
         for args in folding_tests:
-            test_icase.write('test({}); // {}\n'.format(', '.join(map(char_hex, args)),
-                                                        ', '.join(map(codepoint_table.name,
-                                                                      args))))
-        test_icase.write("""
+            test_icase.write(
+                "test({}); // {}\n".format(
+                    ", ".join(map(char_hex, args)),
+                    ", ".join(map(codepoint_table.name, args)),
+                )
+            )
+        test_icase.write(
+            """
 if (typeof reportCompare === "function")
     reportCompare(true, true);
-""")
+"""
+        )
 
 
-def make_unicode_file(version,
-                      table, index,
-                      folding_table, folding_index,
-                      non_bmp_space_set,
-                      non_bmp_id_start_set, non_bmp_id_cont_set,
-                      unconditional_toupper,
-                      codepoint_table):
+def make_unicode_file(
+    version,
+    table,
+    index,
+    folding_table,
+    folding_index,
+    non_bmp_space_set,
+    non_bmp_id_start_set,
+    non_bmp_id_cont_set,
+    unconditional_toupper,
+    codepoint_table,
+):
     index1, index2, shift = splitbins(index)
 
     # Don't forget to update CharInfo in Unicode.h if you need to change this
     assert shift == 6
 
     folding_index1, folding_index2, folding_shift = splitbins(folding_index)
 
     # Don't forget to update CaseFoldInfo in Unicode.h if you need to change this
@@ -1072,17 +1211,19 @@ def make_unicode_file(version,
 
         assert test == table[idx]
 
     # verify correctness
     for char in folding_index:
         test = folding_table[folding_index[char]]
 
         idx = folding_index1[char >> folding_shift]
-        idx = folding_index2[(idx << folding_shift) + (char & ((1 << folding_shift) - 1))]
+        idx = folding_index2[
+            (idx << folding_shift) + (char & ((1 << folding_shift) - 1))
+        ]
 
         assert test == folding_table[idx]
 
     comment = """
 /*
  * So how does indexing work?
  * First let's have a look at a char16_t, 16-bits:
  *              [................]
@@ -1124,112 +1265,127 @@ def make_unicode_file(version,
  *   push index >> shift to index1
  *
  *  increase shift
  *  stop if you found the best shift
  */
 """
 
     def dump(data, name, println):
-        println('const uint8_t unicode::{}[] = {{'.format(name))
+        println("const uint8_t unicode::{}[] = {{".format(name))
 
-        line = pad = ' ' * 4
+        line = pad = " " * 4
         lines = []
         for entry in data:
             assert entry < 256
             s = str(entry)
             s = s.rjust(3)
 
             if len(line + s) + 5 > 99:
                 lines.append(line.rstrip())
-                line = pad + s + ', '
+                line = pad + s + ", "
             else:
-                line = line + s + ', '
+                line = line + s + ", "
         lines.append(line.rstrip())
 
-        println('\n'.join(lines))
-        println('};')
+        println("\n".join(lines))
+        println("};")
 
     def write_table(data_type, name, tbl, idx1_name, idx1, idx2_name, idx2, println):
-        println('const {} unicode::{}[] = {{'.format(data_type, name))
+        println("const {} unicode::{}[] = {{".format(data_type, name))
         for d in tbl:
-            println('    {{ {} }},'.format(', '.join(str(e) for e in d)))
-        println('};')
-        println('')
+            println("    {{ {} }},".format(", ".join(str(e) for e in d)))
+        println("};")
+        println("")
 
         dump(idx1, idx1_name, println)
-        println('')
+        println("")
         dump(idx2, idx2_name, println)
-        println('')
+        println("")
 
     def write_supplemental_identifier_method(name, group_set, println):
-        println('bool')
-        println('js::unicode::{}(uint32_t codePoint)'.format(name))
-        println('{')
+        println("bool")
+        println("js::unicode::{}(uint32_t codePoint)".format(name))
+        println("{")
         for (from_code, to_code) in int_ranges(group_set.keys()):
-            println('    if (codePoint >= 0x{:X} && codePoint <= 0x{:X}) {{ // {} .. {}'
-                    .format(from_code,
-                            to_code,
-                            codepoint_table.name(from_code),
-                            codepoint_table.name(to_code)))
-            println('        return true;')
-            println('    }')
-        println('    return false;')
-        println('}')
-        println('')
+            println(
+                "    if (codePoint >= 0x{:X} && codePoint <= 0x{:X}) {{ // {} .. {}".format(
+                    from_code,
+                    to_code,
+                    codepoint_table.name(from_code),
+                    codepoint_table.name(to_code),
+                )
+            )
+            println("        return true;")
+            println("    }")
+        println("    return false;")
+        println("}")
+        println("")
 
-    file_name = 'Unicode.cpp'
-    with io.open(file_name, 'w', encoding='utf-8') as data_file:
-        write = partial(print, file=data_file, sep='', end='')
-        println = partial(print, file=data_file, sep='', end='\n')
+    file_name = "Unicode.cpp"
+    with io.open(file_name, "w", encoding="utf-8") as data_file:
+        write = partial(print, file=data_file, sep="", end="")
+        println = partial(print, file=data_file, sep="", end="\n")
 
         write(warning_message)
         write(unicode_version_message.format(version))
         write(public_domain)
         println('#include "util/Unicode.h"')
-        println('')
-        println('using namespace js;')
-        println('using namespace js::unicode;')
+        println("")
+        println("using namespace js;")
+        println("using namespace js::unicode;")
         write(comment)
 
-        write_table('CharacterInfo',
-                    'js_charinfo', table,
-                    'index1', index1,
-                    'index2', index2,
-                    println)
+        write_table(
+            "CharacterInfo",
+            "js_charinfo",
+            table,
+            "index1",
+            index1,
+            "index2",
+            index2,
+            println,
+        )
 
-        write_table('FoldingInfo',
-                    'js_foldinfo', folding_table,
-                    'folding_index1', folding_index1,
-                    'folding_index2', folding_index2,
-                    println)
+        write_table(
+            "FoldingInfo",
+            "js_foldinfo",
+            folding_table,
+            "folding_index1",
+            folding_index1,
+            "folding_index2",
+            folding_index2,
+            println,
+        )
 
         # If the following assert fails, it means space character is added to
         # non-BMP area.  In that case the following code should be uncommented
         # and the corresponding code should be added to frontend.  (At least
         # unicode::IsSpace will require updating to handle this.)
         assert len(non_bmp_space_set.keys()) == 0
 
-        write_supplemental_identifier_method('IsIdentifierStartNonBMP', non_bmp_id_start_set,
-                                             println)
+        write_supplemental_identifier_method(
+            "IsIdentifierStartNonBMP", non_bmp_id_start_set, println
+        )
 
-        write_supplemental_identifier_method('IsIdentifierPartNonBMP', non_bmp_id_cont_set,
-                                             println)
+        write_supplemental_identifier_method(
+            "IsIdentifierPartNonBMP", non_bmp_id_cont_set, println
+        )
 
         write_special_casing_methods(unconditional_toupper, codepoint_table, println)
 
         write_ascii_lookup_tables(table, index, write, println)
 
         write_latin1_lookup_tables(table, index, write, println)
 
 
 def getsize(data):
     """ return smallest possible integer size for the given array """
     maxdata = max(data)
-    assert maxdata < 2**32
+    assert maxdata < 2 ** 32
 
     if maxdata < 256:
         return 1
     elif maxdata < 65536:
         return 2
     else:
         return 4
 
@@ -1241,157 +1397,176 @@ def splitbins(t):
     many of the ints are the same.  t1 and t2 are lists of ints, and shift
     is an int, chosen to minimize the combined size of t1 and t2 (in C
     code), and where for each i in range(len(t)),
         t[i] == t2[(t1[i >> shift] << shift) + (i & mask)]
     where mask is a bitmask isolating the last "shift" bits.
     """
 
     def dump(t1, t2, shift, bytes):
-        print("%d+%d bins at shift %d; %d bytes" % (
-            len(t1), len(t2), shift, bytes), file=sys.stderr)
-        print("Size of original table:", len(t)*getsize(t),
-              "bytes", file=sys.stderr)
-    n = len(t)-1    # last valid index
-    maxshift = 0    # the most we can shift n and still have something left
+        print(
+            "%d+%d bins at shift %d; %d bytes" % (len(t1), len(t2), shift, bytes),
+            file=sys.stderr,
+        )
+        print("Size of original table:", len(t) * getsize(t), "bytes", file=sys.stderr)
+
+    n = len(t) - 1  # last valid index
+    maxshift = 0  # the most we can shift n and still have something left
     if n > 0:
         while n >> 1:
             n >>= 1
             maxshift += 1
     del n
     bytes = sys.maxsize  # smallest total size so far
-    t = tuple(t)    # so slices can be dict keys
+    t = tuple(t)  # so slices can be dict keys
     for shift in range(maxshift + 1):
         t1 = []
         t2 = []
-        size = 2**shift
+        size = 2 ** shift
         bincache = {}
 
         for i in range(0, len(t), size):
-            bin = t[i:i + size]
+            bin = t[i : i + size]
 
             index = bincache.get(bin)
             if index is None:
                 index = len(t2)
                 bincache[bin] = index
                 t2.extend(bin)
             t1.append(index >> shift)
 
         # determine memory size
         b = len(t1) * getsize(t1) + len(t2) * getsize(t2)
         if b < bytes:
             best = t1, t2, shift
             bytes = b
     t1, t2, shift = best
 
-    print("Best:", end=' ', file=sys.stderr)
+    print("Best:", end=" ", file=sys.stderr)
     dump(t1, t2, shift, bytes)
 
     # exhaustively verify that the decomposition is correct
-    mask = 2**shift - 1
+    mask = 2 ** shift - 1
     for i in range(len(t)):
         assert t[i] == t2[(t1[i >> shift] << shift) + (i & mask)]
     return best
 
 
 def update_unicode(args):
     base_path = os.getcwd()
 
     version = args.version
     if version is not None:
-        baseurl = 'https://unicode.org/Public'
-        if version == 'UNIDATA':
-            url = '%s/%s' % (baseurl, version)
+        baseurl = "https://unicode.org/Public"
+        if version == "UNIDATA":
+            url = "%s/%s" % (baseurl, version)
         else:
-            url = '%s/%s/ucd' % (baseurl, version)
+            url = "%s/%s/ucd" % (baseurl, version)
 
-    print('Arguments:')
+    print("Arguments:")
     if version is not None:
-        print('\tVersion: %s' % version)
-        print('\tDownload url: %s' % url)
+        print("\tVersion: %s" % version)
+        print("\tDownload url: %s" % url)
 
-        request_url = '{}/UCD.zip'.format(url)
+        request_url = "{}/UCD.zip".format(url)
         with closing(urlopen(request_url)) as downloaded_file:
             downloaded_data = io.BytesIO(downloaded_file.read())
 
         with ZipFile(downloaded_data) as zip_file:
-            for fname in ['UnicodeData.txt',
-                          'CaseFolding.txt',
-                          'DerivedCoreProperties.txt',
-                          'SpecialCasing.txt']:
+            for fname in [
+                "UnicodeData.txt",
+                "CaseFolding.txt",
+                "DerivedCoreProperties.txt",
+                "SpecialCasing.txt",
+            ]:
                 zip_file.extract(fname, path=base_path)
     else:
-        print('\tUsing local files.')
-        print('\tAlways make sure you have the newest Unicode files!')
-    print('')
+        print("\tUsing local files.")
+        print("\tAlways make sure you have the newest Unicode files!")
+    print("")
 
     def version_from_file(f, fname):
         pat_version = re.compile(r"# %s-(?P<version>\d+\.\d+\.\d+).txt" % fname)
         return pat_version.match(f.readline()).group("version")
 
-    with io.open(os.path.join(base_path, 'UnicodeData.txt'),
-                 'r', encoding='utf-8') as unicode_data, \
-            io.open(os.path.join(base_path, 'CaseFolding.txt'),
-                    'r', encoding='utf-8') as case_folding, \
-            io.open(os.path.join(base_path, 'DerivedCoreProperties.txt'),
-                    'r', encoding='utf-8') as derived_core_properties, \
-            io.open(os.path.join(base_path, 'SpecialCasing.txt'),
-                    'r', encoding='utf-8') as special_casing:
-        unicode_version = version_from_file(derived_core_properties, 'DerivedCoreProperties')
+    with io.open(
+        os.path.join(base_path, "UnicodeData.txt"), "r", encoding="utf-8"
+    ) as unicode_data, io.open(
+        os.path.join(base_path, "CaseFolding.txt"), "r", encoding="utf-8"
+    ) as case_folding, io.open(
+        os.path.join(base_path, "DerivedCoreProperties.txt"), "r", encoding="utf-8"
+    ) as derived_core_properties, io.open(
+        os.path.join(base_path, "SpecialCasing.txt"), "r", encoding="utf-8"
+    ) as special_casing:
+        unicode_version = version_from_file(
+            derived_core_properties, "DerivedCoreProperties"
+        )
 
-        print('Processing...')
-        (
-            table, index,
-            non_bmp_lower_map, non_bmp_upper_map,
-            non_bmp_space_set,
-            non_bmp_id_start_set, non_bmp_id_cont_set,
-            codepoint_table, test_space_table
-        ) = process_unicode_data(unicode_data, derived_core_properties)
+        print("Processing...")
         (
-            folding_table, folding_index,
-            folding_tests
-        ) = process_case_folding(case_folding)
-        (
-            unconditional_tolower, unconditional_toupper
-        ) = process_special_casing(special_casing, table, index)
+            table,
+            index,
+            non_bmp_lower_map,
+            non_bmp_upper_map,
+            non_bmp_space_set,
+            non_bmp_id_start_set,
+            non_bmp_id_cont_set,
+            codepoint_table,
+            test_space_table,
+        ) = process_unicode_data(unicode_data, derived_core_properties)
+        (folding_table, folding_index, folding_tests) = process_case_folding(
+            case_folding
+        )
+        (unconditional_tolower, unconditional_toupper) = process_special_casing(
+            special_casing, table, index
+        )
 
-    print('Generating...')
-    make_unicode_file(unicode_version,
-                      table, index,
-                      folding_table, folding_index,
-                      non_bmp_space_set,
-                      non_bmp_id_start_set, non_bmp_id_cont_set,
-                      unconditional_toupper,
-                      codepoint_table)
-    make_non_bmp_file(unicode_version,
-                      non_bmp_lower_map, non_bmp_upper_map,
-                      codepoint_table)
+    print("Generating...")
+    make_unicode_file(
+        unicode_version,
+        table,
+        index,
+        folding_table,
+        folding_index,
+        non_bmp_space_set,
+        non_bmp_id_start_set,
+        non_bmp_id_cont_set,
+        unconditional_toupper,
+        codepoint_table,
+    )
+    make_non_bmp_file(
+        unicode_version, non_bmp_lower_map, non_bmp_upper_map, codepoint_table
+    )
 
-    make_bmp_mapping_test(unicode_version,
-                          codepoint_table, unconditional_tolower, unconditional_toupper)
-    make_non_bmp_mapping_test(unicode_version, non_bmp_upper_map,
-                              non_bmp_lower_map, codepoint_table)
+    make_bmp_mapping_test(
+        unicode_version, codepoint_table, unconditional_tolower, unconditional_toupper
+    )
+    make_non_bmp_mapping_test(
+        unicode_version, non_bmp_upper_map, non_bmp_lower_map, codepoint_table
+    )
     make_space_test(unicode_version, test_space_table, codepoint_table)
     make_regexp_space_test(unicode_version, test_space_table, codepoint_table)
     make_icase_test(unicode_version, folding_tests, codepoint_table)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     import argparse
 
     # This script must be run from js/src/util to work correctly.
-    if '/'.join(os.path.normpath(os.getcwd()).split(os.sep)[-3:]) != 'js/src/util':
-        raise RuntimeError('%s must be run from js/src/util' % sys.argv[0])
+    if "/".join(os.path.normpath(os.getcwd()).split(os.sep)[-3:]) != "js/src/util":
+        raise RuntimeError("%s must be run from js/src/util" % sys.argv[0])
 
-    parser = argparse.ArgumentParser(description='Update Unicode data.')
+    parser = argparse.ArgumentParser(description="Update Unicode data.")
 
-    parser.add_argument('--version',
-                        help='Optional Unicode version number. If specified, downloads the\
+    parser.add_argument(
+        "--version",
+        help='Optional Unicode version number. If specified, downloads the\
                               selected version from <https://unicode.org/Public>. If not specified\
                               uses the existing local files to generate the Unicode data. The\
                               number must match a published Unicode version, e.g. use\
                               "--version=8.0.0" to download Unicode 8 files. Alternatively use\
-                              "--version=UNIDATA" to download the latest published version.')
+                              "--version=UNIDATA" to download the latest published version.',
+    )
 
     parser.set_defaults(func=update_unicode)
 
     args = parser.parse_args()
     args.func(args)

--- a/mobile/android/mach_commands.py
+++ b/mobile/android/mach_commands.py
@@ -46,249 +46,361 @@ def REMOVED(cls):
 
     See https://developer.mozilla.org/en-US/docs/Simple_Firefox_for_Android_build#Developing_Firefox_for_Android_in_Android_Studio_or_IDEA_IntelliJ.  # NOQA: E501
     """
     return False
 
 
 @CommandProvider
 class MachCommands(MachCommandBase):
-    @Command('android', category='devenv',
-             description='Run Android-specific commands.',
-             conditions=[conditions.is_android])
+    @Command(
+        "android",
+        category="devenv",
+        description="Run Android-specific commands.",
+        conditions=[conditions.is_android],
+    )
     def android(self):
         pass
 
-    @SubCommand('android', 'assemble-app',
-                """Assemble Firefox for Android.
-        See http://firefox-source-docs.mozilla.org/build/buildsystem/toolchains.html#firefox-for-android-with-gradle""")  # NOQA: E501
-    @CommandArgument('args', nargs=argparse.REMAINDER)
+    @SubCommand(
+        "android",
+        "assemble-app",
+        """Assemble Firefox for Android.
+        See http://firefox-source-docs.mozilla.org/build/buildsystem/toolchains.html#firefox-for-android-with-gradle""",  # NOQA: E501
+    )
+    @CommandArgument("args", nargs=argparse.REMAINDER)
     def android_assemble_app(self, args):
-        ret = self.gradle(self.substs['GRADLE_ANDROID_APP_TASKS'] +
-                          ['-x', 'lint'] + args, verbose=True)
+        ret = self.gradle(
+            self.substs["GRADLE_ANDROID_APP_TASKS"] + ["-x", "lint"] + args,
+            verbose=True,
+        )
 
         return ret
 
-    @SubCommand('android', 'generate-sdk-bindings',
-                """Generate SDK bindings used when building GeckoView.""")
-    @CommandArgument('inputs', nargs='+', help='config files, '
-                     'like [/path/to/ClassName-classes.txt]+')
-    @CommandArgument('args', nargs=argparse.REMAINDER)
+    @SubCommand(
+        "android",
+        "generate-sdk-bindings",
+        """Generate SDK bindings used when building GeckoView.""",
+    )
+    @CommandArgument(
+        "inputs",
+        nargs="+",
+        help="config files, " "like [/path/to/ClassName-classes.txt]+",
+    )
+    @CommandArgument("args", nargs=argparse.REMAINDER)
     def android_generate_sdk_bindings(self, inputs, args):
         import itertools
 
         def stem(input):
             # Turn "/path/to/ClassName-classes.txt" into "ClassName".
-            return os.path.basename(input).rsplit('-classes.txt', 1)[0]
+            return os.path.basename(input).rsplit("-classes.txt", 1)[0]
 
-        bindings_inputs = list(itertools.chain(*((input, stem(input)) for input in inputs)))
-        bindings_args = '-Pgenerate_sdk_bindings_args={}'.format(';'.join(bindings_inputs))
+        bindings_inputs = list(
+            itertools.chain(*((input, stem(input)) for input in inputs))
+        )
+        bindings_args = "-Pgenerate_sdk_bindings_args={}".format(
+            ";".join(bindings_inputs)
+        )
 
         ret = self.gradle(
-            self.substs['GRADLE_ANDROID_GENERATE_SDK_BINDINGS_TASKS'] + [bindings_args] + args,
-            verbose=True)
+            self.substs["GRADLE_ANDROID_GENERATE_SDK_BINDINGS_TASKS"]
+            + [bindings_args]
+            + args,
+            verbose=True,
+        )
 
         return ret
 
-    @SubCommand('android', 'generate-generated-jni-wrappers',
-                """Generate GeckoView JNI wrappers used when building GeckoView.""")
-    @CommandArgument('args', nargs=argparse.REMAINDER)
+    @SubCommand(
+        "android",
+        "generate-generated-jni-wrappers",
+        """Generate GeckoView JNI wrappers used when building GeckoView.""",
+    )
+    @CommandArgument("args", nargs=argparse.REMAINDER)
     def android_generate_generated_jni_wrappers(self, args):
         ret = self.gradle(
-            self.substs['GRADLE_ANDROID_GENERATE_GENERATED_JNI_WRAPPERS_TASKS'] + args,
-            verbose=True)
+            self.substs["GRADLE_ANDROID_GENERATE_GENERATED_JNI_WRAPPERS_TASKS"] + args,
+            verbose=True,
+        )
 
         return ret
 
-    @SubCommand('android', 'api-lint',
-                """Run Android api-lint.
-REMOVED/DEPRECATED: Use 'mach lint --linter android-api-lint'.""")
+    @SubCommand(
+        "android",
+        "api-lint",
+        """Run Android api-lint.
+REMOVED/DEPRECATED: Use 'mach lint --linter android-api-lint'.""",
+    )
     def android_apilint_REMOVED(self):
         print(LINT_DEPRECATION_MESSAGE)
         return 1
 
-    @SubCommand('android', 'test',
-                """Run Android test.
-REMOVED/DEPRECATED: Use 'mach lint --linter android-test'.""")
+    @SubCommand(
+        "android",
+        "test",
+        """Run Android test.
+REMOVED/DEPRECATED: Use 'mach lint --linter android-test'.""",
+    )
     def android_test_REMOVED(self):
         print(LINT_DEPRECATION_MESSAGE)
         return 1
 
-    @SubCommand('android', 'lint',
-                """Run Android lint.
-REMOVED/DEPRECATED: Use 'mach lint --linter android-lint'.""")
+    @SubCommand(
+        "android",
+        "lint",
+        """Run Android lint.
+REMOVED/DEPRECATED: Use 'mach lint --linter android-lint'.""",
+    )
     def android_lint_REMOVED(self):
         print(LINT_DEPRECATION_MESSAGE)
         return 1
 
-    @SubCommand('android', 'checkstyle',
-                """Run Android checkstyle.
-REMOVED/DEPRECATED: Use 'mach lint --linter android-checkstyle'.""")
+    @SubCommand(
+        "android",
+        "checkstyle",
+        """Run Android checkstyle.
+REMOVED/DEPRECATED: Use 'mach lint --linter android-checkstyle'.""",
+    )
     def android_checkstyle_REMOVED(self):
         print(LINT_DEPRECATION_MESSAGE)
         return 1
 
-    @SubCommand('android', 'gradle-dependencies',
-                """Collect Android Gradle dependencies.
-        See http://firefox-source-docs.mozilla.org/build/buildsystem/toolchains.html#firefox-for-android-with-gradle""")  # NOQA: E501
-    @CommandArgument('args', nargs=argparse.REMAINDER)
+    @SubCommand(
+        "android",
+        "gradle-dependencies",
+        """Collect Android Gradle dependencies.
+        See http://firefox-source-docs.mozilla.org/build/buildsystem/toolchains.html#firefox-for-android-with-gradle""",  # NOQA: E501
+    )
+    @CommandArgument("args", nargs=argparse.REMAINDER)
     def android_gradle_dependencies(self, args):
         # We don't want to gate producing dependency archives on clean
         # lint or checkstyle, particularly because toolchain versions
         # can change the outputs for those processes.
-        self.gradle(self.substs['GRADLE_ANDROID_DEPENDENCIES_TASKS'] +
-                    ["--continue"] + args, verbose=True)
+        self.gradle(
+            self.substs["GRADLE_ANDROID_DEPENDENCIES_TASKS"] + ["--continue"] + args,
+            verbose=True,
+        )
 
         return 0
 
-    @SubCommand('android', 'archive-geckoview',
-                """Create GeckoView archives.
-        See http://firefox-source-docs.mozilla.org/build/buildsystem/toolchains.html#firefox-for-android-with-gradle""")  # NOQA: E501
-    @CommandArgument('args', nargs=argparse.REMAINDER)
+    @SubCommand(
+        "android",
+        "archive-geckoview",
+        """Create GeckoView archives.
+        See http://firefox-source-docs.mozilla.org/build/buildsystem/toolchains.html#firefox-for-android-with-gradle""",  # NOQA: E501
+    )
+    @CommandArgument("args", nargs=argparse.REMAINDER)
     def android_archive_geckoview(self, args):
         ret = self.gradle(
-            self.substs['GRADLE_ANDROID_ARCHIVE_GECKOVIEW_TASKS'] + args,
-            verbose=True)
+            self.substs["GRADLE_ANDROID_ARCHIVE_GECKOVIEW_TASKS"] + args, verbose=True
+        )
 
         return ret
 
-    @SubCommand('android', 'build-geckoview_example',
-                """Build geckoview_example """)
-    @CommandArgument('args', nargs=argparse.REMAINDER)
+    @SubCommand("android", "build-geckoview_example", """Build geckoview_example """)
+    @CommandArgument("args", nargs=argparse.REMAINDER)
     def android_build_geckoview_example(self, args):
-        self.gradle(self.substs['GRADLE_ANDROID_BUILD_GECKOVIEW_EXAMPLE_TASKS'] + args,
-                    verbose=True)
+        self.gradle(
+            self.substs["GRADLE_ANDROID_BUILD_GECKOVIEW_EXAMPLE_TASKS"] + args,
+            verbose=True,
+        )
 
-        print('Execute `mach android install-geckoview_example` '
-              'to push the geckoview_example and test APKs to a device.')
+        print(
+            "Execute `mach android install-geckoview_example` "
+            "to push the geckoview_example and test APKs to a device."
+        )
 
         return 0
 
-    @SubCommand('android', 'install-geckoview_example',
-                """Install geckoview_example """)
-    @CommandArgument('args', nargs=argparse.REMAINDER)
+    @SubCommand(
+        "android", "install-geckoview_example", """Install geckoview_example """
+    )
+    @CommandArgument("args", nargs=argparse.REMAINDER)
     def android_install_geckoview_example(self, args):
-        self.gradle(self.substs['GRADLE_ANDROID_INSTALL_GECKOVIEW_EXAMPLE_TASKS'] + args,
-                    verbose=True)
+        self.gradle(
+            self.substs["GRADLE_ANDROID_INSTALL_GECKOVIEW_EXAMPLE_TASKS"] + args,
+            verbose=True,
+        )
 
-        print('Execute `mach android build-geckoview_example` '
-              'to just build the geckoview_example and test APKs.')
+        print(
+            "Execute `mach android build-geckoview_example` "
+            "to just build the geckoview_example and test APKs."
+        )
 
         return 0
 
-    @SubCommand('android', 'geckoview-docs',
-                """Create GeckoView javadoc and optionally upload to Github""")
-    @CommandArgument('--archive', action='store_true',
-                     help='Generate a javadoc archive.')
-    @CommandArgument('--upload', metavar='USER/REPO',
-                     help='Upload geckoview documentation to Github, '
-                     'using the specified USER/REPO.')
-    @CommandArgument('--upload-branch', metavar='BRANCH[/PATH]',
-                     default='gh-pages',
-                     help='Use the specified branch/path for documentation commits.')
-    @CommandArgument('--javadoc-path', metavar='/PATH',
-                     default='javadoc',
-                     help='Use the specified path for javadoc commits.')
-    @CommandArgument('--upload-message', metavar='MSG',
-                     default='GeckoView docs upload',
-                     help='Use the specified message for commits.')
-    def android_geckoview_docs(self, archive, upload, upload_branch, javadoc_path,
-                               upload_message):
+    @SubCommand(
+        "android",
+        "geckoview-docs",
+        """Create GeckoView javadoc and optionally upload to Github""",
+    )
+    @CommandArgument(
+        "--archive", action="store_true", help="Generate a javadoc archive."
+    )
+    @CommandArgument(
+        "--upload",
+        metavar="USER/REPO",
+        help="Upload geckoview documentation to Github, "
+        "using the specified USER/REPO.",
+    )
+    @CommandArgument(
+        "--upload-branch",
+        metavar="BRANCH[/PATH]",
+        default="gh-pages",
+        help="Use the specified branch/path for documentation commits.",
+    )
+    @CommandArgument(
+        "--javadoc-path",
+        metavar="/PATH",
+        default="javadoc",
+        help="Use the specified path for javadoc commits.",
+    )
+    @CommandArgument(
+        "--upload-message",
+        metavar="MSG",
+        default="GeckoView docs upload",
+        help="Use the specified message for commits.",
+    )
+    def android_geckoview_docs(
+        self, archive, upload, upload_branch, javadoc_path, upload_message
+    ):
 
-        tasks = (self.substs['GRADLE_ANDROID_GECKOVIEW_DOCS_ARCHIVE_TASKS'] if archive or upload
-                 else self.substs['GRADLE_ANDROID_GECKOVIEW_DOCS_TASKS'])
+        tasks = (
+            self.substs["GRADLE_ANDROID_GECKOVIEW_DOCS_ARCHIVE_TASKS"]
+            if archive or upload
+            else self.substs["GRADLE_ANDROID_GECKOVIEW_DOCS_TASKS"]
+        )
 
         ret = self.gradle(tasks, verbose=True)
         if ret or not upload:
             return ret
 
         # Upload to Github.
         fmt = {
-            'level': os.environ.get('MOZ_SCM_LEVEL', '0'),
-            'project': os.environ.get('MH_BRANCH', 'unknown'),
-            'revision': os.environ.get('GECKO_HEAD_REV', 'tip'),
+            "level": os.environ.get("MOZ_SCM_LEVEL", "0"),
+            "project": os.environ.get("MH_BRANCH", "unknown"),
+            "revision": os.environ.get("GECKO_HEAD_REV", "tip"),
         }
         env = {}
 
         # In order to push to GitHub from TaskCluster, we store a private key
         # in the TaskCluster secrets store in the format {"content": "<KEY>"},
         # and the corresponding public key as a writable deploy key for the
         # destination repo on GitHub.
-        secret = os.environ.get('GECKOVIEW_DOCS_UPLOAD_SECRET', '').format(**fmt)
+        secret = os.environ.get("GECKOVIEW_DOCS_UPLOAD_SECRET", "").format(**fmt)
         if secret:
             # Set up a private key from the secrets store if applicable.
             import requests
-            req = requests.get('http://taskcluster/secrets/v1/secret/' + secret)
+
+            req = requests.get("http://taskcluster/secrets/v1/secret/" + secret)
             req.raise_for_status()
 
-            keyfile = mozpath.abspath('gv-docs-upload-key')
-            with open(keyfile, 'w') as f:
+            keyfile = mozpath.abspath("gv-docs-upload-key")
+            with open(keyfile, "w") as f:
                 os.chmod(keyfile, 0o600)
-                f.write(req.json()['secret']['content'])
+                f.write(req.json()["secret"]["content"])
 
             # Turn off strict host key checking so ssh does not complain about
             # unknown github.com host. We're not pushing anything sensitive, so
             # it's okay to not check GitHub's host keys.
-            env['GIT_SSH_COMMAND'] = 'ssh -i "%s" -o StrictHostKeyChecking=no' % keyfile
+            env["GIT_SSH_COMMAND"] = 'ssh -i "%s" -o StrictHostKeyChecking=no' % keyfile
 
         # Clone remote repo.
         branch = upload_branch.format(**fmt)
-        repo_url = 'git@github.com:%s.git' % upload
-        repo_path = mozpath.abspath('gv-docs-repo')
-        self.run_process(['git', 'clone', '--branch', upload_branch, '--depth', '1',
-                          repo_url, repo_path], append_env=env, pass_thru=True)
-        env['GIT_DIR'] = mozpath.join(repo_path, '.git')
-        env['GIT_WORK_TREE'] = repo_path
-        env['GIT_AUTHOR_NAME'] = env['GIT_COMMITTER_NAME'] = 'GeckoView Docs Bot'
-        env['GIT_AUTHOR_EMAIL'] = env['GIT_COMMITTER_EMAIL'] = 'nobody@mozilla.com'
+        repo_url = "git@github.com:%s.git" % upload
+        repo_path = mozpath.abspath("gv-docs-repo")
+        self.run_process(
+            [
+                "git",
+                "clone",
+                "--branch",
+                upload_branch,
+                "--depth",
+                "1",
+                repo_url,
+                repo_path,
+            ],
+            append_env=env,
+            pass_thru=True,
+        )
+        env["GIT_DIR"] = mozpath.join(repo_path, ".git")
+        env["GIT_WORK_TREE"] = repo_path
+        env["GIT_AUTHOR_NAME"] = env["GIT_COMMITTER_NAME"] = "GeckoView Docs Bot"
+        env["GIT_AUTHOR_EMAIL"] = env["GIT_COMMITTER_EMAIL"] = "nobody@mozilla.com"
 
         # Copy over user documentation.
         import mozfile
 
         # Extract new javadoc to specified directory inside repo.
-        src_tar = mozpath.join(self.topobjdir, 'gradle', 'build', 'mobile', 'android',
-                               'geckoview', 'libs', 'geckoview-javadoc.jar')
+        src_tar = mozpath.join(
+            self.topobjdir,
+            "gradle",
+            "build",
+            "mobile",
+            "android",
+            "geckoview",
+            "libs",
+            "geckoview-javadoc.jar",
+        )
         dst_path = mozpath.join(repo_path, javadoc_path.format(**fmt))
         mozfile.remove(dst_path)
         mozfile.extract_zip(src_tar, dst_path)
 
         # Commit and push.
-        self.run_process(['git', 'add', '--all'], append_env=env, pass_thru=True)
-        if self.run_process(['git', 'diff', '--cached', '--quiet'],
-                            append_env=env, pass_thru=True, ensure_exit_code=False) != 0:
+        self.run_process(["git", "add", "--all"], append_env=env, pass_thru=True)
+        if (
+            self.run_process(
+                ["git", "diff", "--cached", "--quiet"],
+                append_env=env,
+                pass_thru=True,
+                ensure_exit_code=False,
+            )
+            != 0
+        ):
             # We have something to commit.
-            self.run_process(['git', 'commit',
-                              '--message', upload_message.format(**fmt)],
-                             append_env=env, pass_thru=True)
-            self.run_process(['git', 'push', 'origin', branch],
-                             append_env=env, pass_thru=True)
+            self.run_process(
+                ["git", "commit", "--message", upload_message.format(**fmt)],
+                append_env=env,
+                pass_thru=True,
+            )
+            self.run_process(
+                ["git", "push", "origin", branch], append_env=env, pass_thru=True
+            )
 
         mozfile.remove(repo_path)
         if secret:
             mozfile.remove(keyfile)
         return 0
 
-    @Command('gradle', category='devenv',
-             description='Run gradle.',
-             conditions=[conditions.is_android])
-    @CommandArgument('-v', '--verbose', action='store_true',
-                     help='Verbose output for what commands the build is running.')
-    @CommandArgument('args', nargs=argparse.REMAINDER)
+    @Command(
+        "gradle",
+        category="devenv",
+        description="Run gradle.",
+        conditions=[conditions.is_android],
+    )
+    @CommandArgument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Verbose output for what commands the build is running.",
+    )
+    @CommandArgument("args", nargs=argparse.REMAINDER)
     def gradle(self, args, verbose=False):
         if not verbose:
             # Avoid logging the command
             self.log_manager.terminal_handler.setLevel(logging.CRITICAL)
 
         # In automation, JAVA_HOME is set via mozconfig, which needs
         # to be specially handled in each mach command. This turns
         # $JAVA_HOME/bin/java into $JAVA_HOME.
-        java_home = os.path.dirname(os.path.dirname(self.substs['JAVA']))
+        java_home = os.path.dirname(os.path.dirname(self.substs["JAVA"]))
 
-        gradle_flags = self.substs.get('GRADLE_FLAGS', '') or \
-            os.environ.get('GRADLE_FLAGS', '')
+        gradle_flags = self.substs.get("GRADLE_FLAGS", "") or os.environ.get(
+            "GRADLE_FLAGS", ""
+        )
         gradle_flags = shell_split(gradle_flags)
 
         # We force the Gradle JVM to run with the UTF-8 encoding, since we
         # filter strings.xml, which is really UTF-8; the ellipsis character is
         # replaced with ??? in some encodings (including ASCII).  It's not yet
         # possible to filter with encodings in Gradle
         # (https://github.com/gradle/gradle/pull/520) and it's challenging to
         # do our filtering with Gradle's Ant support.  Moreover, all of the
@@ -299,124 +411,175 @@ REMOVED/DEPRECATED: Use 'mach lint --lin
         # It's not even enough to set the encoding just for Gradle; it
         # needs to be for JVMs spawned by Gradle as well.  This
         # happens during the maven deployment generating the GeckoView
         # documents; this works around "error: unmappable character
         # for encoding ASCII" in exoplayer2.  See
         # https://discuss.gradle.org/t/unmappable-character-for-encoding-ascii-when-building-a-utf-8-project/10692/11  # NOQA: E501
         # and especially https://stackoverflow.com/a/21755671.
 
-        if self.substs.get('MOZ_AUTOMATION'):
-            gradle_flags += ['--console=plain']
+        if self.substs.get("MOZ_AUTOMATION"):
+            gradle_flags += ["--console=plain"]
 
         env = os.environ.copy()
-        env.update({
-            'GRADLE_OPTS': '-Dfile.encoding=utf-8',
-            'JAVA_HOME': java_home,
-            'JAVA_TOOL_OPTIONS': '-Dfile.encoding=utf-8',
-        })
+        env.update(
+            {
+                "GRADLE_OPTS": "-Dfile.encoding=utf-8",
+                "JAVA_HOME": java_home,
+                "JAVA_TOOL_OPTIONS": "-Dfile.encoding=utf-8",
+            }
+        )
         # Set ANDROID_SDK_ROOT if --with-android-sdk was set.
         # See https://bugzilla.mozilla.org/show_bug.cgi?id=1576471
-        android_sdk_root = self.substs.get('ANDROID_SDK_ROOT', '')
+        android_sdk_root = self.substs.get("ANDROID_SDK_ROOT", "")
         if android_sdk_root:
-            env['ANDROID_SDK_ROOT'] = android_sdk_root
+            env["ANDROID_SDK_ROOT"] = android_sdk_root
 
         return self.run_process(
-            [self.substs['GRADLE']] + gradle_flags + args,
+            [self.substs["GRADLE"]] + gradle_flags + args,
             explicit_env=env,
             pass_thru=True,  # Allow user to run gradle interactively.
             ensure_exit_code=False,  # Don't throw on non-zero exit code.
-            cwd=mozpath.join(self.topsrcdir))
+            cwd=mozpath.join(self.topsrcdir),
+        )
 
-    @Command('gradle-install', category='devenv',
-             conditions=[REMOVED])
+    @Command("gradle-install", category="devenv", conditions=[REMOVED])
     def gradle_install_REMOVED(self):
         pass
 
 
 @CommandProvider
 class AndroidEmulatorCommands(MachCommandBase):
     """
-       Run the Android emulator with one of the AVDs used in the Mozilla
-       automated test environment. If necessary, the AVD is fetched from
-       the tooltool server and installed.
+    Run the Android emulator with one of the AVDs used in the Mozilla
+    automated test environment. If necessary, the AVD is fetched from
+    the tooltool server and installed.
     """
-    @Command('android-emulator', category='devenv',
-             conditions=[],
-             description='Run the Android emulator with an AVD from test automation. '
-                         'Environment variable MOZ_EMULATOR_COMMAND_ARGS, if present, will '
-                         'over-ride the command line arguments used to launch the emulator.')
-    @CommandArgument('--version', metavar='VERSION',
-                     choices=['arm-4.3', 'x86-7.0'],
-                     help='Specify which AVD to run in emulator. '
-                     'One of "arm-4.3" (Android 4.3 supporting armv7 binaries), or '
-                     '"x86-7.0" (Android 7.0 supporting x86 or x86_64 binaries, '
-                     'recommended for most applications). '
-                     'By default, "arm-4.3" will be used if the current build environment '
-                     'architecture is arm; otherwise "x86-7.0".')
-    @CommandArgument('--wait', action='store_true',
-                     help='Wait for emulator to be closed.')
-    @CommandArgument('--force-update', action='store_true',
-                     help='Update AVD definition even when AVD is already installed.')
-    @CommandArgument('--gpu',
-                     help='Over-ride the emulator -gpu argument.')
-    @CommandArgument('--verbose', action='store_true',
-                     help='Log informative status messages.')
-    def emulator(self, version, wait=False, force_update=False, gpu=None, verbose=False):
+
+    @Command(
+        "android-emulator",
+        category="devenv",
+        conditions=[],
+        description="Run the Android emulator with an AVD from test automation. "
+        "Environment variable MOZ_EMULATOR_COMMAND_ARGS, if present, will "
+        "over-ride the command line arguments used to launch the emulator.",
+    )
+    @CommandArgument(
+        "--version",
+        metavar="VERSION",
+        choices=["arm-4.3", "x86-7.0"],
+        help="Specify which AVD to run in emulator. "
+        'One of "arm-4.3" (Android 4.3 supporting armv7 binaries), or '
+        '"x86-7.0" (Android 7.0 supporting x86 or x86_64 binaries, '
+        "recommended for most applications). "
+        'By default, "arm-4.3" will be used if the current build environment '
+        'architecture is arm; otherwise "x86-7.0".',
+    )
+    @CommandArgument(
+        "--wait", action="store_true", help="Wait for emulator to be closed."
+    )
+    @CommandArgument(
+        "--force-update",
+        action="store_true",
+        help="Update AVD definition even when AVD is already installed.",
+    )
+    @CommandArgument("--gpu", help="Over-ride the emulator -gpu argument.")
+    @CommandArgument(
+        "--verbose", action="store_true", help="Log informative status messages."
+    )
+    def emulator(
+        self, version, wait=False, force_update=False, gpu=None, verbose=False
+    ):
         from mozrunner.devices.android_device import AndroidEmulator
 
-        emulator = AndroidEmulator(version, verbose, substs=self.substs,
-                                   device_serial='emulator-5554')
+        emulator = AndroidEmulator(
+            version, verbose, substs=self.substs, device_serial="emulator-5554"
+        )
         if emulator.is_running():
             # It is possible to run multiple emulators simultaneously, but:
             #  - if more than one emulator is using the same avd, errors may
             #    occur due to locked resources;
             #  - additional parameters must be specified when running tests,
             #    to select a specific device.
             # To avoid these complications, allow just one emulator at a time.
-            self.log(logging.ERROR, "emulator", {},
-                     "An Android emulator is already running.\n"
-                     "Close the existing emulator and re-run this command.")
+            self.log(
+                logging.ERROR,
+                "emulator",
+                {},
+                "An Android emulator is already running.\n"
+                "Close the existing emulator and re-run this command.",
+            )
             return 1
 
         if not emulator.is_available():
-            self.log(logging.WARN, "emulator", {},
-                     "Emulator binary not found.\n"
-                     "Install the Android SDK and make sure 'emulator' is in your PATH.")
+            self.log(
+                logging.WARN,
+                "emulator",
+                {},
+                "Emulator binary not found.\n"
+                "Install the Android SDK and make sure 'emulator' is in your PATH.",
+            )
             return 2
 
         if not emulator.check_avd(force_update):
-            self.log(logging.INFO, "emulator", {},
-                     "Fetching and installing AVD. This may take a few minutes...")
+            self.log(
+                logging.INFO,
+                "emulator",
+                {},
+                "Fetching and installing AVD. This may take a few minutes...",
+            )
             emulator.update_avd(force_update)
 
-        self.log(logging.INFO, "emulator", {},
-                 "Starting Android emulator running %s..." %
-                 emulator.get_avd_description())
+        self.log(
+            logging.INFO,
+            "emulator",
+            {},
+            "Starting Android emulator running %s..." % emulator.get_avd_description(),
+        )
         emulator.start(gpu)
         if emulator.wait_for_start():
-            self.log(logging.INFO, "emulator", {},
-                     "Android emulator is running.")
+            self.log(logging.INFO, "emulator", {}, "Android emulator is running.")
         else:
             # This is unusual but the emulator may still function.
-            self.log(logging.WARN, "emulator", {},
-                     "Unable to verify that emulator is running.")
+            self.log(
+                logging.WARN,
+                "emulator",
+                {},
+                "Unable to verify that emulator is running.",
+            )
 
         if conditions.is_android(self):
-            self.log(logging.INFO, "emulator", {},
-                     "Use 'mach install' to install or update Firefox on your emulator.")
+            self.log(
+                logging.INFO,
+                "emulator",
+                {},
+                "Use 'mach install' to install or update Firefox on your emulator.",
+            )
         else:
-            self.log(logging.WARN, "emulator", {},
-                     "No Firefox for Android build detected.\n"
-                     "Switch to a Firefox for Android build context or use 'mach bootstrap'\n"
-                     "to setup an Android build environment.")
+            self.log(
+                logging.WARN,
+                "emulator",
+                {},
+                "No Firefox for Android build detected.\n"
+                "Switch to a Firefox for Android build context or use 'mach bootstrap'\n"
+                "to setup an Android build environment.",
+            )
 
         if wait:
-            self.log(logging.INFO, "emulator", {},
-                     "Waiting for Android emulator to close...")
+            self.log(
+                logging.INFO, "emulator", {}, "Waiting for Android emulator to close..."
+            )
             rc = emulator.wait()
             if rc is not None:
-                self.log(logging.INFO, "emulator", {},
-                         "Android emulator completed with return code %d." % rc)
+                self.log(
+                    logging.INFO,
+                    "emulator",
+                    {},
+                    "Android emulator completed with return code %d." % rc,
+                )
             else:
-                self.log(logging.WARN, "emulator", {},
-                         "Unable to retrieve Android emulator return code.")
+                self.log(
+                    logging.WARN,
+                    "emulator",
+                    {},
+                    "Unable to retrieve Android emulator return code.",
+                )
         return 0