merge mozilla-central to autoland. r=merge a=merge
authorSebastian Hengst <archaeopteryx@coole-files.de>
Thu, 21 Dec 2017 13:38:16 +0200
changeset 397142 044988e8a4251f5722b9ea6bc3117b3801b53858
parent 397141 b5c9bb05168d5ce9c92f500d25516b19d0a3062a (current diff)
parent 397123 5b1fdaa14d35ddf1a638c9422786ede707cacf1f (diff)
child 397143 106a1cbeb62cc41d55bfa38e8ca0f4af0cf08e7c
push id33127
push useraiakab@mozilla.com
push dateThu, 21 Dec 2017 22:17:05 +0000
treeherdermozilla-central@d20967c26da5 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge, merge
milestone59.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
merge mozilla-central to autoland. r=merge a=merge
browser/components/preferences/donottrack.xul
browser/locales/en-US/chrome/browser/preferences/donottrack.dtd
js/src/frontend/BinSource.cpp
--- a/accessible/xul/XULListboxAccessible.cpp
+++ b/accessible/xul/XULListboxAccessible.cpp
@@ -151,17 +151,17 @@ XULListboxAccessible::Value(nsString& aV
   }
 }
 
 role
 XULListboxAccessible::NativeRole()
 {
   // A richlistbox is used with the new autocomplete URL bar, and has a parent
   // popup <panel>.
-  if (mContent->GetParent()->IsXULElement(nsGkAtoms::panel))
+  if (mContent->GetParent() && mContent->GetParent()->IsXULElement(nsGkAtoms::panel))
     return roles::COMBOBOX_LIST;
 
   return IsMulticolumn() ? roles::TABLE : roles::LISTBOX;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULListboxAccessible: Table
 
--- a/browser/branding/nightly/configure.sh
+++ b/browser/branding/nightly/configure.sh
@@ -1,5 +1,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 MOZ_APP_DISPLAYNAME=Nightly
+MOZ_MACBUNDLE_ID=nightly
+
--- a/browser/components/extensions/test/xpcshell/head.js
+++ b/browser/components/extensions/test/xpcshell/head.js
@@ -41,17 +41,17 @@ ExtensionTestUtils.init(this);
  *        port. The latter is the preferred behavior.
  *
  * @returns {HttpServer}
  */
 function createHttpServer(port = -1) {
   let server = new HttpServer();
   server.start(port);
 
-  do_register_cleanup(() => {
+  registerCleanupFunction(() => {
     return new Promise(resolve => {
       server.stop(resolve);
     });
   });
 
   return server;
 }
 
--- a/browser/components/extensions/test/xpcshell/test_ext_browsingData_settings.js
+++ b/browser/components/extensions/test/xpcshell/test_ext_browsingData_settings.js
@@ -50,17 +50,17 @@ add_task(async function testSettingsProp
   for (let key of Object.keys(dataTypeSet)) {
     equal(true, dataTypeSet[key], `${key} property of dataRemovalPermitted is true.`);
   }
 
   // Explicitly set a pref to both true and false and then check.
   const SINGLE_OPTION = "cache";
   const SINGLE_PREF = "privacy.cpd.cache";
 
-  do_register_cleanup(() => {
+  registerCleanupFunction(() => {
     Preferences.reset(SINGLE_PREF);
   });
 
   Preferences.set(SINGLE_PREF, true);
 
   extension.sendMessage("settings");
   settings = await extension.awaitMessage("settings");
   equal(settings.dataToRemove[SINGLE_OPTION], true, "Preference that was set to true returns true.");
@@ -95,17 +95,17 @@ add_task(async function testSettingsSinc
     background,
     manifest: {
       permissions: ["browsingData"],
     },
   });
 
   await extension.startup();
 
-  do_register_cleanup(() => {
+  registerCleanupFunction(() => {
     Preferences.reset(TIMESPAN_PREF);
   });
 
   for (let timespan in TEST_DATA) {
     Preferences.set(TIMESPAN_PREF, Sanitizer[timespan]);
 
     extension.sendMessage("settings");
     let settings = await extension.awaitMessage("settings");
--- a/browser/components/extensions/test/xpcshell/test_ext_pkcs11_management.js
+++ b/browser/components/extensions/test/xpcshell/test_ext_pkcs11_management.js
@@ -8,17 +8,17 @@ XPCOMUtils.defineLazyModuleGetters(this,
 
 do_get_profile();
 let tmpDir = FileUtils.getDir("TmpD", ["PKCS11"]);
 let slug = AppConstants.platform === "linux" ? "pkcs11-modules" : "PKCS11Modules";
 tmpDir.createUnique(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
 let baseDir = OS.Path.join(tmpDir.path, slug);
 OS.File.makeDir(baseDir);
 
-do_register_cleanup(() => {
+registerCleanupFunction(() => {
   tmpDir.remove(true);
 });
 
 function getPath(filename) {
   return OS.Path.join(baseDir, filename);
 }
 
 const testmodule = "../../../../../security/manager/ssl/tests/unit/pkcs11testmodule/" + ctypes.libraryName("pkcs11testmodule");
@@ -52,30 +52,30 @@ async function setupManifests(modules) {
           } else if (property == "XRESysNativeManifests") {
             return tmpDir.clone();
           }
           return null;
         },
       };
 
       Services.dirsvc.registerProvider(dirProvider);
-      do_register_cleanup(() => {
+      registerCleanupFunction(() => {
         Services.dirsvc.unregisterProvider(dirProvider);
       });
 
       for (let module of modules) {
         await writeManifest(module);
       }
       break;
 
     case "win":
       const REGKEY = String.raw`Software\Mozilla\PKCS11Modules`;
 
       let registry = new MockRegistry();
-      do_register_cleanup(() => {
+      registerCleanupFunction(() => {
         registry.shutdown();
       });
 
       for (let module of modules) {
         if (!OS.Path.winIsAbsolute(module.path)) {
           let cwd = await OS.File.getCurrentDirectory();
           module.path = OS.Path.join(cwd, module.path);
         }
--- a/browser/components/feeds/test/unit/test_355473.js
+++ b/browser/components/feeds/test/unit/test_355473.js
@@ -21,23 +21,23 @@ function run_test() {
   });
 
   var httpsChannel = NetUtil.newChannel({
     uri: httpsFeedURI,
     loadUsingSystemPrincipal: true
   });
 
   // not setting .originalURI to the original URI is naughty
-  do_check_true(feedFeedURI.equals(feedChannel.originalURI));
-  do_check_true(httpFeedURI.equals(httpChannel.originalURI));
-  do_check_true(httpsFeedURI.equals(httpsChannel.originalURI));
+  Assert.ok(feedFeedURI.equals(feedChannel.originalURI));
+  Assert.ok(httpFeedURI.equals(httpChannel.originalURI));
+  Assert.ok(httpsFeedURI.equals(httpsChannel.originalURI));
 
   // actually using the horrible mess that's a feed: URI is suicidal
-  do_check_true(httpURI.equals(feedChannel.URI));
-  do_check_true(httpURI.equals(httpChannel.URI));
-  do_check_true(httpsURI.equals(httpsChannel.URI));
+  Assert.ok(httpURI.equals(feedChannel.URI));
+  Assert.ok(httpURI.equals(httpChannel.URI));
+  Assert.ok(httpsURI.equals(httpsChannel.URI));
 
   // check that we throw creating feed: URIs from file and ftp
   Assert.throws(function() { Services.io.newURI("feed:ftp://example.com/feed.xml"); },
       "Should throw an exception when trying to create a feed: URI with an ftp: inner");
   Assert.throws(function() { Services.io.newURI("feed:file:///var/feed.xml"); },
       "Should throw an exception when trying to create a feed: URI with a file: inner");
 }
--- a/browser/components/migration/tests/unit/head_migration.js
+++ b/browser/components/migration/tests/unit/head_migration.js
@@ -59,15 +59,15 @@ function registerFakePath(key, file) {
   } catch (e) {
     // dirsvc.get will throw if nothing provides for the key and dirsvc.undefine
     // will throw if it's not a persistent entry, in either case we don't want
     // to set the original file in cleanup.
     originalFile = undefined;
   }
 
   dirsvc.set(key, file);
-  do_register_cleanup(() => {
+  registerCleanupFunction(() => {
     dirsvc.undefine(key);
     if (originalFile) {
       dirsvc.set(key, originalFile);
     }
   });
 }
--- a/browser/components/migration/tests/unit/test_Chrome_passwords.js
+++ b/browser/components/migration/tests/unit/test_Chrome_passwords.js
@@ -126,17 +126,17 @@ function generateDifferentLogin(login) {
   return newLogin;
 }
 
 add_task(async function setup() {
   let loginDataFile = do_get_file("AppData/Local/Google/Chrome/User Data/Default/Login Data");
   dbConn = await Sqlite.openConnection({ path: loginDataFile.path });
   registerFakePath("LocalAppData", do_get_file("AppData/Local/"));
 
-  do_register_cleanup(() => {
+  registerCleanupFunction(() => {
     Services.logins.removeAllLogins();
     crypto.finalize();
     return dbConn.close();
   });
 });
 
 add_task(async function test_importIntoEmptyDB() {
   for (let login of TEST_LOGINS) {
--- a/browser/components/migration/tests/unit/test_IE7_passwords.js
+++ b/browser/components/migration/tests/unit/test_IE7_passwords.js
@@ -330,17 +330,17 @@ add_task(async function test_passwordsNo
 add_task(async function test_passwordsAvailable() {
   if (AppConstants.isPlatformAndVersionAtLeast("win", "6.2")) {
     return;
   }
 
   let crypto = new OSCrypto();
   let hashes = []; // the hashes of all migrator websites, this is going to be used for the clean up
 
-  do_register_cleanup(() => {
+  registerCleanupFunction(() => {
     Services.logins.removeAllLogins();
     logins = Services.logins.getAllLogins({});
     Assert.equal(logins.length, 0, "There are no logins after the cleanup");
     // remove all the values created in this test from the registry
     removeAllValues(Storage2Key, hashes);
     // restore all backed up values
     restore(Storage2Key);
 
--- a/browser/components/migration/tests/unit/test_IE_cookies.js
+++ b/browser/components/migration/tests/unit/test_IE_cookies.js
@@ -61,17 +61,17 @@ add_task(async function() {
     href: `http://mycookietest.${Math.random()}.com`,
     name: "testcookie",
     value: "testvalue",
     expiry: new Date(new Date().setDate(date + 2))
   };
   let data = ctypes.char16_t.array()(256);
   let sizeRef = DWORD(256).address();
 
-  do_register_cleanup(() => {
+  registerCleanupFunction(() => {
     // Remove the cookie.
     try {
       let expired = new Date(new Date().setDate(date - 2));
       let rv = setIECookie(COOKIE.href, COOKIE.name,
                            `; expires=${expired.toUTCString()}`);
       Assert.ok(rv, "Expired the IE cookie");
       Assert.ok(!getIECookie(COOKIE.href, COOKIE.name, data, sizeRef),
       "The cookie has been properly removed");
@@ -86,17 +86,17 @@ add_task(async function() {
   // Create the persistent cookie in IE.
   let value = `${COOKIE.value}; expires=${COOKIE.expiry.toUTCString()}`;
   let rv = setIECookie(COOKIE.href, COOKIE.name, value);
   Assert.ok(rv, "Added a persistent IE cookie: " + value);
 
   // Sanity check the cookie has been created.
   Assert.ok(getIECookie(COOKIE.href, COOKIE.name, data, sizeRef),
             "Found the added persistent IE cookie");
-  do_print("Found cookie: " + data.readString());
+  info("Found cookie: " + data.readString());
   Assert.equal(data.readString(), `${COOKIE.name}=${COOKIE.value}`,
             "Found the expected cookie");
 
   // Sanity check that there are no cookies.
   Assert.equal(Services.cookies.countCookiesFromHost(COOKIE.host), 0,
                "There are no cookies initially");
 
   // Migrate cookies.
--- a/browser/components/migration/tests/unit/test_MigrationUtils_timedRetry.js
+++ b/browser/components/migration/tests/unit/test_MigrationUtils_timedRetry.js
@@ -5,17 +5,17 @@ XPCOMUtils.defineLazyModuleGetter(this, 
 
 let tmpFile = FileUtils.getDir("TmpD", [], true);
 let dbConn;
 
 add_task(async function setup() {
   tmpFile.append("TestDB");
   dbConn = await Sqlite.openConnection({ path: tmpFile.path });
 
-  do_register_cleanup(() => {
+  registerCleanupFunction(() => {
     dbConn.close();
     OS.File.remove(tmpFile.path);
   });
 });
 
 add_task(async function testgetRowsFromDBWithoutLocksRetries() {
   let promise = MigrationUtils.getRowsFromDBWithoutLocks(tmpFile.path,
                                                          "Temp DB",
--- a/browser/components/migration/tests/unit/test_automigration.js
+++ b/browser/components/migration/tests/unit/test_automigration.js
@@ -20,17 +20,17 @@ AutoMigrateBackstage.MigrationUtils = ne
     }
     if (name == "getMigrator" && gShimmedMigrator) {
       return function() { return gShimmedMigrator; };
     }
     return MigrationUtils[name];
   },
 });
 
-do_register_cleanup(function() {
+registerCleanupFunction(function() {
   AutoMigrateBackstage.MigrationUtils = MigrationUtils;
 });
 
 // This should be replaced by using History.fetch with a fetchVisits option,
 // once that becomes available
 async function visitsForURL(url) {
   let visitCount = 0;
   let db = await PlacesUtils.promiseDBConnection();
@@ -111,17 +111,17 @@ add_task(async function checkProfilePick
 
 /**
  * Test the complete automatic process including browser and profile selection,
  * and actual migration (which implies startup)
  */
 add_task(async function checkIntegration() {
   gShimmedMigrator = {
     get sourceProfiles() {
-      do_print("Read sourceProfiles");
+      info("Read sourceProfiles");
       return null;
     },
     getMigrateData(profileToMigrate) {
       this._getMigrateDataArgs = profileToMigrate;
       return Ci.nsIBrowserProfileMigrator.BOOKMARKS;
     },
     migrate(types, startup, profileToMigrate) {
       this._migrateArgs = [types, startup, profileToMigrate];
@@ -142,17 +142,17 @@ add_task(async function checkIntegration
 
 /**
  * Test the undo preconditions and a no-op undo in the automigrator.
  */
 add_task(async function checkUndoPreconditions() {
   let shouldAddData = false;
   gShimmedMigrator = {
     get sourceProfiles() {
-      do_print("Read sourceProfiles");
+      info("Read sourceProfiles");
       return null;
     },
     getMigrateData(profileToMigrate) {
       this._getMigrateDataArgs = profileToMigrate;
       return Ci.nsIBrowserProfileMigrator.BOOKMARKS;
     },
     migrate(types, startup, profileToMigrate) {
       this._migrateArgs = [types, startup, profileToMigrate];
@@ -625,27 +625,27 @@ add_task(async function checkUndoVisitsS
     },
     onClearHistory() {
       wrongMethodDeferred.reject("Unexpected call to onClearHistory");
     },
     onPageChanged(uri) {
       wrongMethodDeferred.reject(new Error("Unexpected call to onPageChanged " + uri.spec));
     },
     onFrecencyChanged(aURI) {
-      do_print("frecency change");
+      info("frecency change");
       Assert.ok(frecencyChangesExpected.has(aURI.spec),
                 "Should be expecting frecency change for " + aURI.spec);
       frecencyChangesExpected.get(aURI.spec).resolve();
     },
     onManyFrecenciesChanged() {
-      do_print("Many frecencies changed");
+      info("Many frecencies changed");
       wrongMethodDeferred.reject(new Error("This test can't deal with onManyFrecenciesChanged to be called"));
     },
     onDeleteURI(aURI) {
-      do_print("delete uri");
+      info("delete uri");
       Assert.ok(uriDeletedExpected.has(aURI.spec),
                 "Should be expecting uri deletion for " + aURI.spec);
       uriDeletedExpected.get(aURI.spec).resolve();
     },
   };
   PlacesUtils.history.addObserver(observer);
 
   await AutoMigrate._removeSomeVisits(undoVisitData);
--- a/browser/components/newtab/tests/xpcshell/test_AboutNewTabService.js
+++ b/browser/components/newtab/tests/xpcshell/test_AboutNewTabService.js
@@ -28,17 +28,17 @@ const ACTIVITY_STREAM_DEBUG_PREF = "brow
 
 function cleanup() {
   Services.prefs.clearUserPref(ACTIVITY_STREAM_PREF);
   Services.prefs.clearUserPref(ACTIVITY_STREAM_PRERENDER_PREF);
   Services.prefs.clearUserPref(ACTIVITY_STREAM_DEBUG_PREF);
   aboutNewTabService.resetNewTabURL();
 }
 
-do_register_cleanup(cleanup);
+registerCleanupFunction(cleanup);
 
 add_task(async function test_as_and_prerender_initialized() {
   Assert.equal(aboutNewTabService.activityStreamEnabled, Services.prefs.getBoolPref(ACTIVITY_STREAM_PREF),
     ".activityStreamEnabled should be set to the correct initial value");
   Assert.equal(aboutNewTabService.activityStreamPrerender, Services.prefs.getBoolPref(ACTIVITY_STREAM_PRERENDER_PREF),
     ".activityStreamPrerender should be set to the correct initial value");
   // This pref isn't defined on release or beta, so we fall back to false
   Assert.equal(aboutNewTabService.activityStreamDebug, Services.prefs.getBoolPref(ACTIVITY_STREAM_DEBUG_PREF, false),
--- a/browser/components/newtab/tests/xpcshell/test_NewTabSearchProvider.js
+++ b/browser/components/newtab/tests/xpcshell/test_NewTabSearchProvider.js
@@ -25,17 +25,17 @@ add_task(async function test_search() {
       if (aData === "init-complete" && aTopic === "browser-search-service") {
         Services.obs.removeObserver(observer, "browser-search-service");
         resolve();
       }
     }, "browser-search-service");
   });
   Services.search.init();
   await observerPromise;
-  do_check_true(Services.search.isInitialized);
+  Assert.ok(Services.search.isInitialized);
 
   // get initial state of search and check it has correct properties
   let state = await NewTabSearchProvider.search.asyncGetState();
   let stateProps = hasProp(state);
   ["engines", "currentEngine"].forEach(stateProps);
 
   // check that the current engine is correct and has correct properties
   let {currentEngine} = state;
--- a/browser/components/places/tests/unit/head_bookmarks.js
+++ b/browser/components/places/tests/unit/head_bookmarks.js
@@ -84,17 +84,17 @@ function rebuildSmartBookmarks() {
         return;
       }
       do_throw("Got console message: " + aMsg.message);
     },
     QueryInterface: XPCOMUtils.generateQI([ Ci.nsIConsoleListener ]),
   };
   Services.console.reset();
   Services.console.registerListener(consoleListener);
-  do_register_cleanup(() => {
+  registerCleanupFunction(() => {
     try {
       Services.console.unregisterListener(consoleListener);
     } catch (ex) { /* will likely fail */ }
   });
   Cc["@mozilla.org/browser/browserglue;1"]
     .getService(Ci.nsIObserver)
     .observe(null, "browser-glue-test", "smart-bookmarks-init");
   return promiseTopicObserved("test-smart-bookmarks-done").then(() => {
--- a/browser/components/places/tests/unit/test_421483.js
+++ b/browser/components/places/tests/unit/test_421483.js
@@ -15,56 +15,56 @@ gluesvc.observe(null, "initial-migration
 add_task(async function smart_bookmarks_disabled() {
   Services.prefs.setIntPref("browser.places.smartBookmarksVersion", -1);
   await rebuildSmartBookmarks();
 
   let smartBookmarkItemIds =
     PlacesUtils.annotations.getItemsWithAnnotation(SMART_BOOKMARKS_ANNO);
   Assert.equal(smartBookmarkItemIds.length, 0);
 
-  do_print("check that pref has not been bumped up");
+  info("check that pref has not been bumped up");
   Assert.equal(Services.prefs.getIntPref("browser.places.smartBookmarksVersion"), -1);
 });
 
 add_task(async function create_smart_bookmarks() {
   Services.prefs.setIntPref("browser.places.smartBookmarksVersion", 0);
   await rebuildSmartBookmarks();
 
   let smartBookmarkItemIds =
     PlacesUtils.annotations.getItemsWithAnnotation(SMART_BOOKMARKS_ANNO);
   Assert.notEqual(smartBookmarkItemIds.length, 0);
 
-  do_print("check that pref has been bumped up");
+  info("check that pref has been bumped up");
   Assert.ok(Services.prefs.getIntPref("browser.places.smartBookmarksVersion") > 0);
 });
 
 add_task(async function remove_smart_bookmark_and_restore() {
   let smartBookmarkItemIds =
     PlacesUtils.annotations.getItemsWithAnnotation(SMART_BOOKMARKS_ANNO);
   let smartBookmarksCount = smartBookmarkItemIds.length;
-  do_print("remove one smart bookmark and restore");
+  info("remove one smart bookmark and restore");
 
   let guid = await PlacesUtils.promiseItemGuid(smartBookmarkItemIds[0]);
   await PlacesUtils.bookmarks.remove(guid);
   Services.prefs.setIntPref("browser.places.smartBookmarksVersion", 0);
 
   await rebuildSmartBookmarks();
   smartBookmarkItemIds =
     PlacesUtils.annotations.getItemsWithAnnotation(SMART_BOOKMARKS_ANNO);
   Assert.equal(smartBookmarkItemIds.length, smartBookmarksCount);
 
-  do_print("check that pref has been bumped up");
+  info("check that pref has been bumped up");
   Assert.ok(Services.prefs.getIntPref("browser.places.smartBookmarksVersion") > 0);
 });
 
 add_task(async function move_smart_bookmark_rename_and_restore() {
   let smartBookmarkItemIds =
     PlacesUtils.annotations.getItemsWithAnnotation(SMART_BOOKMARKS_ANNO);
   let smartBookmarksCount = smartBookmarkItemIds.length;
-  do_print("smart bookmark should be restored in place");
+  info("smart bookmark should be restored in place");
 
   let guid = await PlacesUtils.promiseItemGuid(smartBookmarkItemIds[0]);
   let bm = await PlacesUtils.bookmarks.fetch(guid);
   let oldTitle = bm.title;
 
   // create a subfolder and move inside it
   let subfolder = await PlacesUtils.bookmarks.insert({
     parentGuid: bm.parentGuid,
@@ -89,11 +89,11 @@ add_task(async function move_smart_bookm
     PlacesUtils.annotations.getItemsWithAnnotation(SMART_BOOKMARKS_ANNO);
   Assert.equal(smartBookmarkItemIds.length, smartBookmarksCount);
 
   guid = await PlacesUtils.promiseItemGuid(smartBookmarkItemIds[0]);
   bm = await PlacesUtils.bookmarks.fetch(guid);
   Assert.equal(bm.parentGuid, subfolder.guid);
   Assert.equal(bm.title, oldTitle);
 
-  do_print("check that pref has been bumped up");
+  info("check that pref has been bumped up");
   Assert.ok(Services.prefs.getIntPref("browser.places.smartBookmarksVersion") > 0);
 });
--- a/browser/components/places/tests/unit/test_PUIU_makeTransaction.js
+++ b/browser/components/places/tests/unit/test_PUIU_makeTransaction.js
@@ -84,20 +84,20 @@ function wrapNodeByIdAndParent(aItemId, 
   return JSON.parse(wrappedNode);
 }
 
 add_test(function test_text_paste() {
   const TEST_URL = "http://places.moz.org/";
   const TEST_TITLE = "Places bookmark";
 
   waitForBookmarkNotification("onItemAdded", function(aData) {
-    do_check_eq(aData.title, TEST_TITLE);
-    do_check_eq(aData.url, TEST_URL);
-    do_check_eq(aData.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
-    do_check_eq(aData.index, 0);
+    Assert.equal(aData.title, TEST_TITLE);
+    Assert.equal(aData.url, TEST_URL);
+    Assert.equal(aData.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
+    Assert.equal(aData.index, 0);
     run_next_test();
   });
 
   let txn = PlacesUIUtils.makeTransaction(
     { title: TEST_TITLE, uri: TEST_URL },
     PlacesUtils.TYPE_X_MOZ_URL,
     PlacesUtils.unfiledBookmarksFolderId,
     PlacesUtils.bookmarks.DEFAULT_INDEX,
@@ -105,30 +105,30 @@ add_test(function test_text_paste() {
   );
   PlacesUtils.transactionManager.doTransaction(txn);
 });
 
 add_test(function test_container() {
   const TEST_TITLE = "Places folder";
 
   waitForBookmarkNotification("onItemChanged", function(aChangedData) {
-    do_check_eq(aChangedData.title, TEST_TITLE);
-    do_check_eq(aChangedData.type, PlacesUtils.bookmarks.TYPE_FOLDER);
-    do_check_eq(aChangedData.index, 1);
+    Assert.equal(aChangedData.title, TEST_TITLE);
+    Assert.equal(aChangedData.type, PlacesUtils.bookmarks.TYPE_FOLDER);
+    Assert.equal(aChangedData.index, 1);
 
     waitForBookmarkNotification("onItemAdded", function(aAddedData) {
-      do_check_eq(aAddedData.title, TEST_TITLE);
-      do_check_eq(aAddedData.type, PlacesUtils.bookmarks.TYPE_FOLDER);
-      do_check_eq(aAddedData.index, 2);
+      Assert.equal(aAddedData.title, TEST_TITLE);
+      Assert.equal(aAddedData.type, PlacesUtils.bookmarks.TYPE_FOLDER);
+      Assert.equal(aAddedData.index, 2);
       let id = aAddedData.id;
 
       waitForBookmarkNotification("onItemMoved", function(aMovedData) {
-        do_check_eq(aMovedData.id, id);
-        do_check_eq(aMovedData.type, PlacesUtils.bookmarks.TYPE_FOLDER);
-        do_check_eq(aMovedData.index, 1);
+        Assert.equal(aMovedData.id, id);
+        Assert.equal(aMovedData.type, PlacesUtils.bookmarks.TYPE_FOLDER);
+        Assert.equal(aMovedData.index, 1);
 
         run_next_test();
       });
 
       let txn = PlacesUIUtils.makeTransaction(
         wrapNodeByIdAndParent(aAddedData.id, PlacesUtils.unfiledBookmarksFolderId),
         0, // Unused for real nodes.
         PlacesUtils.unfiledBookmarksFolderId,
@@ -161,28 +161,28 @@ add_test(function test_container() {
   PlacesUtils.annotations.setItemAnnotation(id, "random-anno",
                                             "random-value", 0,
                                             PlacesUtils.annotations.EXPIRE_NEVER);
 });
 
 
 add_test(function test_separator() {
   waitForBookmarkNotification("onItemChanged", function(aChangedData) {
-    do_check_eq(aChangedData.type, PlacesUtils.bookmarks.TYPE_SEPARATOR);
-    do_check_eq(aChangedData.index, 3);
+    Assert.equal(aChangedData.type, PlacesUtils.bookmarks.TYPE_SEPARATOR);
+    Assert.equal(aChangedData.index, 3);
 
     waitForBookmarkNotification("onItemAdded", function(aAddedData) {
-      do_check_eq(aAddedData.type, PlacesUtils.bookmarks.TYPE_SEPARATOR);
-      do_check_eq(aAddedData.index, 4);
+      Assert.equal(aAddedData.type, PlacesUtils.bookmarks.TYPE_SEPARATOR);
+      Assert.equal(aAddedData.index, 4);
       let id = aAddedData.id;
 
       waitForBookmarkNotification("onItemMoved", function(aMovedData) {
-        do_check_eq(aMovedData.id, id);
-        do_check_eq(aMovedData.type, PlacesUtils.bookmarks.TYPE_SEPARATOR);
-        do_check_eq(aMovedData.index, 1);
+        Assert.equal(aMovedData.id, id);
+        Assert.equal(aMovedData.type, PlacesUtils.bookmarks.TYPE_SEPARATOR);
+        Assert.equal(aMovedData.index, 1);
 
         run_next_test();
       });
 
       let txn = PlacesUIUtils.makeTransaction(
         wrapNodeByIdAndParent(aAddedData.id, PlacesUtils.unfiledBookmarksFolderId),
         0, // Unused for real nodes.
         PlacesUtils.unfiledBookmarksFolderId,
@@ -213,32 +213,32 @@ add_test(function test_separator() {
                                             PlacesUtils.annotations.EXPIRE_NEVER);
 });
 
 add_test(function test_bookmark() {
   const TEST_URL = "http://places.moz.org/";
   const TEST_TITLE = "Places bookmark";
 
   waitForBookmarkNotification("onItemChanged", function(aChangedData) {
-    do_check_eq(aChangedData.title, TEST_TITLE);
-    do_check_eq(aChangedData.url, TEST_URL);
-    do_check_eq(aChangedData.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
-    do_check_eq(aChangedData.index, 5);
+    Assert.equal(aChangedData.title, TEST_TITLE);
+    Assert.equal(aChangedData.url, TEST_URL);
+    Assert.equal(aChangedData.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
+    Assert.equal(aChangedData.index, 5);
 
     waitForBookmarkNotification("onItemAdded", function(aAddedData) {
-      do_check_eq(aAddedData.title, TEST_TITLE);
-      do_check_eq(aAddedData.url, TEST_URL);
-      do_check_eq(aAddedData.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
-      do_check_eq(aAddedData.index, 6);
+      Assert.equal(aAddedData.title, TEST_TITLE);
+      Assert.equal(aAddedData.url, TEST_URL);
+      Assert.equal(aAddedData.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
+      Assert.equal(aAddedData.index, 6);
       let id = aAddedData.id;
 
       waitForBookmarkNotification("onItemMoved", function(aMovedData) {
-        do_check_eq(aMovedData.id, id);
-        do_check_eq(aMovedData.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
-        do_check_eq(aMovedData.index, 1);
+        Assert.equal(aMovedData.id, id);
+        Assert.equal(aMovedData.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
+        Assert.equal(aMovedData.index, 1);
 
         run_next_test();
       });
 
       let txn = PlacesUIUtils.makeTransaction(
         wrapNodeByIdAndParent(aAddedData.id, PlacesUtils.unfiledBookmarksFolderId),
         0, // Unused for real nodes.
         PlacesUtils.unfiledBookmarksFolderId,
@@ -274,26 +274,26 @@ add_test(function test_bookmark() {
                                             PlacesUtils.annotations.EXPIRE_NEVER);
 });
 
 add_test(function test_visit() {
   const TEST_URL = "http://places.moz.org/";
   const TEST_TITLE = "Places bookmark";
 
   waitForBookmarkNotification("onItemAdded", function(aAddedData) {
-    do_check_eq(aAddedData.title, TEST_TITLE);
-    do_check_eq(aAddedData.url, TEST_URL);
-    do_check_eq(aAddedData.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
-    do_check_eq(aAddedData.index, 7);
+    Assert.equal(aAddedData.title, TEST_TITLE);
+    Assert.equal(aAddedData.url, TEST_URL);
+    Assert.equal(aAddedData.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
+    Assert.equal(aAddedData.index, 7);
 
     waitForBookmarkNotification("onItemAdded", function(aAddedData2) {
-      do_check_eq(aAddedData2.title, TEST_TITLE);
-      do_check_eq(aAddedData2.url, TEST_URL);
-      do_check_eq(aAddedData2.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
-      do_check_eq(aAddedData2.index, 8);
+      Assert.equal(aAddedData2.title, TEST_TITLE);
+      Assert.equal(aAddedData2.url, TEST_URL);
+      Assert.equal(aAddedData2.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);
+      Assert.equal(aAddedData2.index, 8);
       run_next_test();
     });
 
     try {
     let node = wrapNodeByIdAndParent(aAddedData.id, PlacesUtils.unfiledBookmarksFolderId);
     // Simulate a not-bookmarked node, will copy it to a new bookmark.
     node.id = -1;
     let txn = PlacesUIUtils.makeTransaction(
@@ -316,15 +316,15 @@ add_test(function test_visit() {
 });
 
 add_test(function check_annotations() {
   // As last step check how many items for each annotation exist.
 
   // Copies should retain the description annotation.
   let descriptions =
     PlacesUtils.annotations.getItemsWithAnnotation(PlacesUIUtils.DESCRIPTION_ANNO, {});
-  do_check_eq(descriptions.length, 4);
+  Assert.equal(descriptions.length, 4);
 
   // Only the original bookmarks should have this annotation.
   let others = PlacesUtils.annotations.getItemsWithAnnotation("random-anno", {});
-  do_check_eq(others.length, 3);
+  Assert.equal(others.length, 3);
   run_next_test();
 });
--- a/browser/components/places/tests/unit/test_browserGlue_bookmarkshtml.js
+++ b/browser/components/places/tests/unit/test_browserGlue_bookmarkshtml.js
@@ -8,17 +8,17 @@
  * Tests that nsBrowserGlue correctly exports bookmarks.html at shutdown if
  * browser.bookmarks.autoExportHTML is set to true.
  */
 
 add_task(async function() {
   remove_bookmarks_html();
 
   Services.prefs.setBoolPref("browser.bookmarks.autoExportHTML", true);
-  do_register_cleanup(() => Services.prefs.clearUserPref("browser.bookmarks.autoExportHTML"));
+  registerCleanupFunction(() => Services.prefs.clearUserPref("browser.bookmarks.autoExportHTML"));
 
   // Initialize nsBrowserGlue before Places.
   Cc["@mozilla.org/browser/browserglue;1"].getService(Ci.nsISupports);
 
   // Initialize Places through the History Service.
   Assert.equal(PlacesUtils.history.databaseStatus,
                PlacesUtils.history.DATABASE_STATUS_CREATE);
 
--- a/browser/components/places/tests/unit/test_browserGlue_corrupt.js
+++ b/browser/components/places/tests/unit/test_browserGlue_corrupt.js
@@ -16,17 +16,17 @@ function run_test() {
   remove_all_JSON_backups();
 
   // Create our JSON backup from bookmarks.glue.json.
   create_JSON_backup("bookmarks.glue.json");
 
   run_next_test();
 }
 
-do_register_cleanup(function() {
+registerCleanupFunction(function() {
   remove_bookmarks_html();
   remove_all_JSON_backups();
   return PlacesUtils.bookmarks.eraseEverything();
 });
 
 add_task(async function test_main() {
   // Create a corrupt database.
   await createCorruptDB();
--- a/browser/components/places/tests/unit/test_browserGlue_corrupt_nobackup.js
+++ b/browser/components/places/tests/unit/test_browserGlue_corrupt_nobackup.js
@@ -14,17 +14,17 @@ function run_test() {
   create_bookmarks_html("bookmarks.glue.html");
 
   // Remove JSON backup from profile.
   remove_all_JSON_backups();
 
   run_next_test();
 }
 
-do_register_cleanup(remove_bookmarks_html);
+registerCleanupFunction(remove_bookmarks_html);
 
 add_task(async function() {
   // Create a corrupt database.
   await createCorruptDB();
 
   // Initialize nsBrowserGlue before Places.
   Cc["@mozilla.org/browser/browserglue;1"].getService(Ci.nsISupports);
 
--- a/browser/components/places/tests/unit/test_browserGlue_corrupt_nobackup_default.js
+++ b/browser/components/places/tests/unit/test_browserGlue_corrupt_nobackup_default.js
@@ -46,10 +46,10 @@ add_task(async function() {
   // Check that default bookmarks have been restored.
   bm = await PlacesUtils.bookmarks.fetch({
     parentGuid: PlacesUtils.bookmarks.toolbarGuid,
     index: SMART_BOOKMARKS_ON_TOOLBAR
   });
 
   // Bug 1283076: Nightly bookmark points to Get Involved page, not Getting Started one
   let chanTitle = AppConstants.NIGHTLY_BUILD ? "Get Involved" : "Getting Started";
-  do_check_eq(bm.title, chanTitle);
+  Assert.equal(bm.title, chanTitle);
 });
--- a/browser/components/places/tests/unit/test_browserGlue_distribution.js
+++ b/browser/components/places/tests/unit/test_browserGlue_distribution.js
@@ -30,17 +30,17 @@ function run_test() {
   let testDistributionFile = gTestDir.clone();
   testDistributionFile.append("distribution.ini");
   testDistributionFile.copyTo(distroDir, "distribution.ini");
   Assert.ok(testDistributionFile.exists());
 
   run_next_test();
 }
 
-do_register_cleanup(function() {
+registerCleanupFunction(function() {
   // Remove the distribution file, even if the test failed, otherwise all
   // next tests will import it.
   let iniFile = gProfD.clone();
   iniFile.leafName = "distribution";
   iniFile.append("distribution.ini");
   if (iniFile.exists()) {
     iniFile.remove(false);
   }
--- a/browser/components/places/tests/unit/test_browserGlue_migrate.js
+++ b/browser/components/places/tests/unit/test_browserGlue_migrate.js
@@ -14,17 +14,17 @@ function run_test() {
   create_bookmarks_html("bookmarks.glue.html");
 
   // Remove current database file.
   clearDB();
 
   run_next_test();
 }
 
-do_register_cleanup(remove_bookmarks_html);
+registerCleanupFunction(remove_bookmarks_html);
 
 add_task(async function test_migrate_bookmarks() {
   // Initialize Places through the History Service and check that a new
   // database has been created.
   Assert.equal(PlacesUtils.history.databaseStatus,
                PlacesUtils.history.DATABASE_STATUS_CREATE);
 
   // A migrator would run before nsBrowserGlue Places initialization, so mimic
--- a/browser/components/places/tests/unit/test_browserGlue_prefs.js
+++ b/browser/components/places/tests/unit/test_browserGlue_prefs.js
@@ -21,26 +21,26 @@ add_task(async function setup() {
   // Create our bookmarks.html from bookmarks.glue.html.
   create_bookmarks_html("bookmarks.glue.html");
 
   remove_all_JSON_backups();
 
   // Create our JSON backup from bookmarks.glue.json.
   create_JSON_backup("bookmarks.glue.json");
 
-  do_register_cleanup(function() {
+  registerCleanupFunction(function() {
     remove_bookmarks_html();
     remove_all_JSON_backups();
 
     return PlacesUtils.bookmarks.eraseEverything();
   });
 });
 
 function simulatePlacesInit() {
-  do_print("Simulate Places init");
+  info("Simulate Places init");
   // Force nsBrowserGlue::_initPlaces().
   bg.observe(null, TOPIC_BROWSERGLUE_TEST, TOPICDATA_FORCE_PLACES_INIT);
   return promiseTopicObserved("places-browser-init-complete");
 }
 
 add_task(async function test_checkPreferences() {
   // Initialize Places through the History Service and check that a new
   // database has been created.
@@ -52,17 +52,17 @@ add_task(async function test_checkPrefer
   // Ensure preferences status.
   Assert.ok(!Services.prefs.getBoolPref(PREF_AUTO_EXPORT_HTML));
 
   Assert.throws(() => Services.prefs.getBoolPref(PREF_IMPORT_BOOKMARKS_HTML));
   Assert.throws(() => Services.prefs.getBoolPref(PREF_RESTORE_DEFAULT_BOOKMARKS));
 });
 
 add_task(async function test_import() {
-  do_print("Import from bookmarks.html if importBookmarksHTML is true.");
+  info("Import from bookmarks.html if importBookmarksHTML is true.");
 
   await PlacesUtils.bookmarks.eraseEverything();
 
   // Sanity check: we should not have any bookmark on the toolbar.
   Assert.ok(!(await PlacesUtils.bookmarks.fetch({
     parentGuid: PlacesUtils.bookmarks.toolbarGuid,
     index: 0
   })));
@@ -80,18 +80,18 @@ add_task(async function test_import() {
   });
   Assert.equal(bm.title, "example");
 
   // Check preferences have been reverted.
   Assert.ok(!Services.prefs.getBoolPref(PREF_IMPORT_BOOKMARKS_HTML));
 });
 
 add_task(async function test_import_noSmartBookmarks() {
-  do_print("import from bookmarks.html, but don't create smart bookmarks " +
-              "if they are disabled");
+  info("import from bookmarks.html, but don't create smart bookmarks " +
+          "if they are disabled");
 
   await PlacesUtils.bookmarks.eraseEverything();
 
   // Sanity check: we should not have any bookmark on the toolbar.
   Assert.ok(!(await PlacesUtils.bookmarks.fetch({
     parentGuid: PlacesUtils.bookmarks.toolbarGuid,
     index: 0
   })));
@@ -110,18 +110,18 @@ add_task(async function test_import_noSm
   });
   Assert.equal(bm.title, "example");
 
   // Check preferences have been reverted.
   Assert.ok(!Services.prefs.getBoolPref(PREF_IMPORT_BOOKMARKS_HTML));
 });
 
 add_task(async function test_import_autoExport_updatedSmartBookmarks() {
-  do_print("Import from bookmarks.html, but don't create smart bookmarks " +
-              "if autoExportHTML is true and they are at latest version");
+  info("Import from bookmarks.html, but don't create smart bookmarks " +
+          "if autoExportHTML is true and they are at latest version");
 
   await PlacesUtils.bookmarks.eraseEverything();
 
   // Sanity check: we should not have any bookmark on the toolbar.
   Assert.ok(!(await PlacesUtils.bookmarks.fetch({
     parentGuid: PlacesUtils.bookmarks.toolbarGuid,
     index: 0
   })));
@@ -143,18 +143,18 @@ add_task(async function test_import_auto
 
   // Check preferences have been reverted.
   Assert.ok(!Services.prefs.getBoolPref(PREF_IMPORT_BOOKMARKS_HTML));
 
   Services.prefs.setBoolPref(PREF_AUTO_EXPORT_HTML, false);
 });
 
 add_task(async function test_import_autoExport_oldSmartBookmarks() {
-  do_print("Import from bookmarks.html, and create smart bookmarks if " +
-              "autoExportHTML is true and they are not at latest version.");
+  info("Import from bookmarks.html, and create smart bookmarks if " +
+          "autoExportHTML is true and they are not at latest version.");
 
   await PlacesUtils.bookmarks.eraseEverything();
 
   // Sanity check: we should not have any bookmark on the toolbar.
   Assert.ok(!(await PlacesUtils.bookmarks.fetch({
     parentGuid: PlacesUtils.bookmarks.toolbarGuid,
     index: 0
   })));
@@ -176,18 +176,18 @@ add_task(async function test_import_auto
 
   // Check preferences have been reverted.
   Assert.ok(!Services.prefs.getBoolPref(PREF_IMPORT_BOOKMARKS_HTML));
 
   Services.prefs.setBoolPref(PREF_AUTO_EXPORT_HTML, false);
 });
 
 add_task(async function test_restore() {
-  do_print("restore from default bookmarks.html if " +
-              "restore_default_bookmarks is true.");
+  info("restore from default bookmarks.html if " +
+          "restore_default_bookmarks is true.");
 
   await PlacesUtils.bookmarks.eraseEverything();
 
   // Sanity check: we should not have any bookmark on the toolbar.
   Assert.ok(!(await PlacesUtils.bookmarks.fetch({
     parentGuid: PlacesUtils.bookmarks.toolbarGuid,
     index: 0
   })));
@@ -203,18 +203,18 @@ add_task(async function test_restore() {
     index: SMART_BOOKMARKS_ON_TOOLBAR
   }));
 
   // Check preferences have been reverted.
   Assert.ok(!Services.prefs.getBoolPref(PREF_RESTORE_DEFAULT_BOOKMARKS));
 });
 
 add_task(async function test_restore_import() {
-  do_print("setting both importBookmarksHTML and " +
-              "restore_default_bookmarks should restore defaults.");
+  info("setting both importBookmarksHTML and " +
+          "restore_default_bookmarks should restore defaults.");
 
   await PlacesUtils.bookmarks.eraseEverything();
 
   // Sanity check: we should not have any bookmark on the toolbar.
   Assert.ok(!(await PlacesUtils.bookmarks.fetch({
     parentGuid: PlacesUtils.bookmarks.toolbarGuid,
     index: 0
   })));
--- a/browser/components/places/tests/unit/test_browserGlue_restore.js
+++ b/browser/components/places/tests/unit/test_browserGlue_restore.js
@@ -19,17 +19,17 @@ function run_test() {
   create_JSON_backup("bookmarks.glue.json");
 
   // Remove current database file.
   clearDB();
 
   run_next_test();
 }
 
-do_register_cleanup(function() {
+registerCleanupFunction(function() {
   remove_bookmarks_html();
   remove_all_JSON_backups();
   return PlacesUtils.bookmarks.eraseEverything();
 });
 
 add_task(async function test_main() {
   // Initialize nsBrowserGlue before Places.
   Cc["@mozilla.org/browser/browserglue;1"].getService(Ci.nsISupports);
--- a/browser/components/places/tests/unit/test_browserGlue_smartBookmarks.js
+++ b/browser/components/places/tests/unit/test_browserGlue_smartBookmarks.js
@@ -15,17 +15,17 @@ const PREF_IMPORT_BOOKMARKS_HTML = "brow
 const PREF_RESTORE_DEFAULT_BOOKMARKS = "browser.bookmarks.restore_default_bookmarks";
 
 function run_test() {
   remove_bookmarks_html();
   remove_all_JSON_backups();
   run_next_test();
 }
 
-do_register_cleanup(() => PlacesUtils.bookmarks.eraseEverything());
+registerCleanupFunction(() => PlacesUtils.bookmarks.eraseEverything());
 
 function countFolderChildren(aFolderItemId) {
   let rootNode = PlacesUtils.getFolderContents(aFolderItemId).root;
   let cc = rootNode.childCount;
   // Dump contents.
   for (let i = 0; i < cc ; i++) {
     let node = rootNode.getChild(i);
     let title = PlacesUtils.nodeIsSeparator(node) ? "---" : node.title;
@@ -48,17 +48,17 @@ add_task(async function setup() {
 
   // Ensure preferences status.
   Assert.ok(!Services.prefs.getBoolPref(PREF_AUTO_EXPORT_HTML));
   Assert.ok(!Services.prefs.getBoolPref(PREF_RESTORE_DEFAULT_BOOKMARKS));
   Assert.throws(() => Services.prefs.getBoolPref(PREF_IMPORT_BOOKMARKS_HTML));
 });
 
 add_task(async function test_version_0() {
-  do_print("All smart bookmarks are created if smart bookmarks version is 0.");
+  info("All smart bookmarks are created if smart bookmarks version is 0.");
 
   // Sanity check: we should have default bookmark.
   Assert.ok(await PlacesUtils.bookmarks.fetch({
     parentGuid: PlacesUtils.bookmarks.toolbarGuid,
     index: 0
   }));
 
   Assert.ok(await PlacesUtils.bookmarks.fetch({
@@ -78,17 +78,17 @@ add_task(async function test_version_0()
                SMART_BOOKMARKS_ON_MENU + DEFAULT_BOOKMARKS_ON_MENU);
 
   // Check version has been updated.
   Assert.equal(Services.prefs.getIntPref(PREF_SMART_BOOKMARKS_VERSION),
                SMART_BOOKMARKS_VERSION);
 });
 
 add_task(async function test_version_change() {
-  do_print("An existing smart bookmark is replaced when version changes.");
+  info("An existing smart bookmark is replaced when version changes.");
 
   // Sanity check: we have a smart bookmark on the toolbar.
   let bm = await PlacesUtils.bookmarks.fetch({
     parentGuid: PlacesUtils.bookmarks.toolbarGuid,
     index: 0
   });
   await checkItemHasAnnotation(bm.guid, SMART_BOOKMARKS_ANNO);
 
@@ -123,17 +123,17 @@ add_task(async function test_version_cha
   Assert.notEqual(bm.title, "new title");
 
   // Check version has been updated.
   Assert.equal(Services.prefs.getIntPref(PREF_SMART_BOOKMARKS_VERSION),
                SMART_BOOKMARKS_VERSION);
 });
 
 add_task(async function test_version_change_pos() {
-  do_print("bookmarks position is retained when version changes.");
+  info("bookmarks position is retained when version changes.");
 
   // Sanity check items.
   Assert.equal(countFolderChildren(PlacesUtils.toolbarFolderId),
                SMART_BOOKMARKS_ON_TOOLBAR + DEFAULT_BOOKMARKS_ON_TOOLBAR);
   Assert.equal(countFolderChildren(PlacesUtils.bookmarksMenuFolderId),
                SMART_BOOKMARKS_ON_MENU + DEFAULT_BOOKMARKS_ON_MENU);
 
   let bm = await PlacesUtils.bookmarks.fetch({
@@ -163,17 +163,17 @@ add_task(async function test_version_cha
   Assert.equal(bm.title, firstItemTitle);
 
   // Check version has been updated.
   Assert.equal(Services.prefs.getIntPref(PREF_SMART_BOOKMARKS_VERSION),
                SMART_BOOKMARKS_VERSION);
 });
 
 add_task(async function test_version_change_pos_moved() {
-  do_print("moved bookmarks position is retained when version changes.");
+  info("moved bookmarks position is retained when version changes.");
 
   // Sanity check items.
   Assert.equal(countFolderChildren(PlacesUtils.toolbarFolderId),
                SMART_BOOKMARKS_ON_TOOLBAR + DEFAULT_BOOKMARKS_ON_TOOLBAR);
   Assert.equal(countFolderChildren(PlacesUtils.bookmarksMenuFolderId),
                SMART_BOOKMARKS_ON_MENU + DEFAULT_BOOKMARKS_ON_MENU);
 
   let bm1 = await PlacesUtils.bookmarks.fetch({
@@ -222,17 +222,17 @@ add_task(async function test_version_cha
   });
 
   // Check version has been updated.
   Assert.equal(Services.prefs.getIntPref(PREF_SMART_BOOKMARKS_VERSION),
               SMART_BOOKMARKS_VERSION);
 });
 
 add_task(async function test_recreation() {
-  do_print("An explicitly removed smart bookmark should not be recreated.");
+  info("An explicitly removed smart bookmark should not be recreated.");
 
   // Remove toolbar's smart bookmarks
   let bm = await PlacesUtils.bookmarks.fetch({
     parentGuid: PlacesUtils.bookmarks.toolbarGuid,
     index: 0
   });
   await PlacesUtils.bookmarks.remove(bm.guid);
 
@@ -255,17 +255,17 @@ add_task(async function test_recreation(
                SMART_BOOKMARKS_ON_MENU + DEFAULT_BOOKMARKS_ON_MENU);
 
   // Check version has been updated.
   Assert.equal(Services.prefs.getIntPref(PREF_SMART_BOOKMARKS_VERSION),
                SMART_BOOKMARKS_VERSION);
 });
 
 add_task(async function test_recreation_version_0() {
-  do_print("Even if a smart bookmark has been removed recreate it if version is 0.");
+  info("Even if a smart bookmark has been removed recreate it if version is 0.");
 
   // Sanity check items.
   Assert.equal(countFolderChildren(PlacesUtils.toolbarFolderId),
                DEFAULT_BOOKMARKS_ON_TOOLBAR);
   Assert.equal(countFolderChildren(PlacesUtils.bookmarksMenuFolderId),
                SMART_BOOKMARKS_ON_MENU + DEFAULT_BOOKMARKS_ON_MENU);
 
   // Set preferences.
--- a/browser/components/places/tests/unit/test_browserGlue_urlbar_defaultbehavior_migration.js
+++ b/browser/components/places/tests/unit/test_browserGlue_urlbar_defaultbehavior_migration.js
@@ -7,17 +7,17 @@ const TOPIC_BROWSERGLUE_TEST = "browser-
 const TOPICDATA_BROWSERGLUE_TEST = "force-ui-migration";
 const DEFAULT_BEHAVIOR_PREF = "browser.urlbar.default.behavior";
 const AUTOCOMPLETE_PREF = "browser.urlbar.autocomplete.enabled";
 
 var gBrowserGlue = Cc["@mozilla.org/browser/browserglue;1"]
                      .getService(Ci.nsIObserver);
 var gGetBoolPref = Services.prefs.getBoolPref;
 
-do_register_cleanup(cleanup);
+registerCleanupFunction(cleanup);
 
 function cleanup() {
   let prefix = "browser.urlbar.suggest.";
   for (let type of ["history", "bookmark", "openpage", "history.onlyTyped"]) {
     Services.prefs.clearUserPref(prefix + type);
   }
   Services.prefs.clearUserPref("browser.migration.version");
   Services.prefs.clearUserPref(AUTOCOMPLETE_PREF);
@@ -29,115 +29,115 @@ function setupBehaviorAndMigrate(aDefaul
   Services.prefs.setIntPref("browser.migration.version", UI_VERSION - 1);
   Services.prefs.setIntPref(DEFAULT_BEHAVIOR_PREF, aDefaultBehavior);
   Services.prefs.setBoolPref(AUTOCOMPLETE_PREF, aAutocompleteEnabled);
   // Simulate a migration.
   gBrowserGlue.observe(null, TOPIC_BROWSERGLUE_TEST, TOPICDATA_BROWSERGLUE_TEST);
 }
 
 add_task(async function() {
-  do_print("Migrate default.behavior = 0");
+  info("Migrate default.behavior = 0");
   setupBehaviorAndMigrate(0);
 
   Assert.ok(gGetBoolPref("browser.urlbar.suggest.history"),
     "History preference should be true.");
   Assert.ok(gGetBoolPref("browser.urlbar.suggest.bookmark"),
     "Bookmark preference should be true.");
   Assert.ok(gGetBoolPref("browser.urlbar.suggest.openpage"),
     "Openpage preference should be true.");
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.history.onlyTyped"), false,
     "Typed preference should be false.");
 });
 
 add_task(async function() {
-  do_print("Migrate default.behavior = 1");
+  info("Migrate default.behavior = 1");
   setupBehaviorAndMigrate(1);
 
   Assert.ok(gGetBoolPref("browser.urlbar.suggest.history"),
     "History preference should be true.");
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.bookmark"), false,
     "Bookmark preference should be false.");
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.openpage"), false,
     "Openpage preference should be false");
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.history.onlyTyped"), false,
     "Typed preference should be false");
 });
 
 add_task(async function() {
-  do_print("Migrate default.behavior = 2");
+  info("Migrate default.behavior = 2");
   setupBehaviorAndMigrate(2);
 
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.history"), false,
     "History preference should be false.");
   Assert.ok(gGetBoolPref("browser.urlbar.suggest.bookmark"),
     "Bookmark preference should be true.");
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.openpage"), false,
     "Openpage preference should be false");
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.history.onlyTyped"), false,
     "Typed preference should be false");
 });
 
 add_task(async function() {
-  do_print("Migrate default.behavior = 3");
+  info("Migrate default.behavior = 3");
   setupBehaviorAndMigrate(3);
 
   Assert.ok(gGetBoolPref("browser.urlbar.suggest.history"),
     "History preference should be true.");
   Assert.ok(gGetBoolPref("browser.urlbar.suggest.bookmark"),
     "Bookmark preference should be true.");
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.openpage"), false,
     "Openpage preference should be false");
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.history.onlyTyped"), false,
     "Typed preference should be false");
 });
 
 add_task(async function() {
-  do_print("Migrate default.behavior = 19");
+  info("Migrate default.behavior = 19");
   setupBehaviorAndMigrate(19);
 
   Assert.ok(gGetBoolPref("browser.urlbar.suggest.history"),
     "History preference should be true.");
   Assert.ok(gGetBoolPref("browser.urlbar.suggest.bookmark"),
     "Bookmark preference should be true.");
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.openpage"), false,
     "Openpage preference should be false");
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.history.onlyTyped"), false,
     "Typed preference should be false");
 });
 
 add_task(async function() {
-  do_print("Migrate default.behavior = 33");
+  info("Migrate default.behavior = 33");
   setupBehaviorAndMigrate(33);
 
   Assert.ok(gGetBoolPref("browser.urlbar.suggest.history"),
     "History preference should be true.");
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.bookmark"), false,
     "Bookmark preference should be false.");
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.openpage"), false,
     "Openpage preference should be false");
   Assert.ok(gGetBoolPref("browser.urlbar.suggest.history.onlyTyped"),
     "Typed preference should be true");
 });
 
 add_task(async function() {
-  do_print("Migrate default.behavior = 129");
+  info("Migrate default.behavior = 129");
   setupBehaviorAndMigrate(129);
 
   Assert.ok(gGetBoolPref("browser.urlbar.suggest.history"),
     "History preference should be true.");
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.bookmark"), false,
     "Bookmark preference should be false.");
   Assert.ok(gGetBoolPref("browser.urlbar.suggest.openpage"),
     "Openpage preference should be true");
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.history.onlyTyped"), false,
     "Typed preference should be false");
 });
 
 add_task(async function() {
-  do_print("Migrate default.behavior = 0, autocomplete.enabled = false");
+  info("Migrate default.behavior = 0, autocomplete.enabled = false");
   setupBehaviorAndMigrate(0, false);
 
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.history"), false,
     "History preference should be false.");
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.bookmark"), false,
     "Bookmark preference should be false.");
   Assert.equal(gGetBoolPref("browser.urlbar.suggest.openpage"), false,
     "Openpage preference should be false");
--- a/browser/components/places/tests/unit/test_clearHistory_shutdown.js
+++ b/browser/components/places/tests/unit/test_clearHistory_shutdown.js
@@ -35,17 +35,17 @@ var formHistoryStartup = Cc["@mozilla.or
                          getService(Ci.nsIObserver);
 formHistoryStartup.observe(null, "profile-after-change", null);
 XPCOMUtils.defineLazyModuleGetter(this, "FormHistory",
                                   "resource://gre/modules/FormHistory.jsm");
 
 var timeInMicroseconds = Date.now() * 1000;
 
 add_task(async function test_execute() {
-  do_print("Initialize browserglue before Places");
+  info("Initialize browserglue before Places");
 
   // Avoid default bookmarks import.
   let glue = Cc["@mozilla.org/browser/browserglue;1"].
              getService(Ci.nsIObserver);
   glue.observe(null, "initial-migration-will-import-default-bookmarks", null);
   glue.observe(null, "test-initialize-sanitizer", null);
 
 
@@ -56,49 +56,49 @@ add_task(async function test_execute() {
   Services.prefs.setBoolPref("privacy.clearOnShutdown.downloads", true);
   Services.prefs.setBoolPref("privacy.clearOnShutdown.cookies", true);
   Services.prefs.setBoolPref("privacy.clearOnShutdown.formData", true);
   Services.prefs.setBoolPref("privacy.clearOnShutdown.sessions", true);
   Services.prefs.setBoolPref("privacy.clearOnShutdown.siteSettings", true);
 
   Services.prefs.setBoolPref("privacy.sanitize.sanitizeOnShutdown", true);
 
-  do_print("Add visits.");
+  info("Add visits.");
   for (let aUrl of URIS) {
     await PlacesTestUtils.addVisits({
       uri: uri(aUrl), visitDate: timeInMicroseconds++,
       transition: PlacesUtils.history.TRANSITION_TYPED
     });
   }
-  do_print("Add cache.");
+  info("Add cache.");
   await storeCache(FTP_URL, "testData");
-  do_print("Add form history.");
+  info("Add form history.");
   await addFormHistory();
   Assert.equal((await getFormHistoryCount()), 1, "Added form history");
 
-  do_print("Simulate and wait shutdown.");
+  info("Simulate and wait shutdown.");
   await shutdownPlaces();
 
   Assert.equal((await getFormHistoryCount()), 0, "Form history cleared");
 
   let stmt = DBConn(true).createStatement(
     "SELECT id FROM moz_places WHERE url = :page_url "
   );
 
   try {
     URIS.forEach(function(aUrl) {
       stmt.params.page_url = aUrl;
-      do_check_false(stmt.executeStep());
+      Assert.ok(!stmt.executeStep());
       stmt.reset();
     });
   } finally {
     stmt.finalize();
   }
 
-  do_print("Check cache");
+  info("Check cache");
   // Check cache.
   await checkCache(FTP_URL);
 });
 
 function addFormHistory() {
   return new Promise(resolve => {
     let now = Date.now() * 1000;
     FormHistory.update({ op: "add",
@@ -128,17 +128,17 @@ function storeCache(aURL, aContent) {
 
   return new Promise(resolve => {
     let storeCacheListener = {
       onCacheEntryCheck(entry, appcache) {
         return Ci.nsICacheEntryOpenCallback.ENTRY_WANTED;
       },
 
       onCacheEntryAvailable(entry, isnew, appcache, status) {
-        do_check_eq(status, Cr.NS_OK);
+        Assert.equal(status, Cr.NS_OK);
 
         entry.setMetaDataElement("servertype", "0");
         var os = entry.openOutputStream(0);
 
         var written = os.write(aContent, aContent.length);
         if (written != aContent.length) {
           do_throw("os.write has not written all data!\n" +
                    "  Expected: " + written + "\n" +
@@ -159,17 +159,17 @@ function storeCache(aURL, aContent) {
 
 function checkCache(aURL) {
   let cache = Services.cache2;
   let storage = cache.diskCacheStorage(LoadContextInfo.default, false);
 
   return new Promise(resolve => {
     let checkCacheListener = {
       onCacheEntryAvailable(entry, isnew, appcache, status) {
-        do_check_eq(status, Cr.NS_ERROR_CACHE_KEY_NOT_FOUND);
+        Assert.equal(status, Cr.NS_ERROR_CACHE_KEY_NOT_FOUND);
         resolve();
       }
     };
 
     storage.asyncOpenURI(Services.io.newURI(aURL), "",
                          Ci.nsICacheStorage.OPEN_READONLY,
                          checkCacheListener);
   });
--- a/browser/components/places/tests/unit/test_leftpane_corruption_handling.js
+++ b/browser/components/places/tests/unit/test_leftpane_corruption_handling.js
@@ -23,17 +23,17 @@ add_task(async function() {
   Assert.ok(!!PlacesUIUtils);
 
   // Check getters.
   gLeftPaneFolderIdGetter = Object.getOwnPropertyDescriptor(PlacesUIUtils, "leftPaneFolderId");
   Assert.equal(typeof(gLeftPaneFolderIdGetter.get), "function");
   gAllBookmarksFolderIdGetter = Object.getOwnPropertyDescriptor(PlacesUIUtils, "allBookmarksFolderId");
   Assert.equal(typeof(gAllBookmarksFolderIdGetter.get), "function");
 
-  do_register_cleanup(() => PlacesUtils.bookmarks.eraseEverything());
+  registerCleanupFunction(() => PlacesUtils.bookmarks.eraseEverything());
 });
 
 add_task(async function() {
   // Add a third party bogus annotated item.  Should not be removed.
   let folder = await PlacesUtils.bookmarks.insert({
     parentGuid: PlacesUtils.bookmarks.unfiledGuid,
     title: "test",
     index: PlacesUtils.bookmarks.DEFAULT_INDEX,
deleted file mode 100644
--- a/browser/components/preferences/donottrack.xul
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0"?>
-
-<!-- This Source Code Form is subject to the terms of the Mozilla Public
-   - License, v. 2.0. If a copy of the MPL was not distributed with this
-   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
-
-<?xml-stylesheet href="chrome://global/skin/"?>
-<?xml-stylesheet href="chrome://browser/skin/preferences/preferences.css"?>
-
-<!DOCTYPE prefwindow [
-<!ENTITY % brandDTD SYSTEM "chrome://branding/locale/brand.dtd">
-<!ENTITY % doNotTrackDTD SYSTEM "chrome://browser/locale/preferences/donottrack.dtd">
-%brandDTD;
-%doNotTrackDTD;
-]>
-
-<prefwindow id="DoNotTrackDialog" type="child"
-            xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
-            xmlns:html="http://www.w3.org/1999/xhtml"
-            title="&window.title;"
-            style="width: &window.width;; height: &window.height;;"
-            dlgbuttons="accept,cancel">
-  <prefpane>
-    <preferences>
-      <preference id="privacy.donottrackheader.enabled"
-                  name="privacy.donottrackheader.enabled"
-                  type="bool"/>
-    </preferences>
-    <hbox align="center" pack="start">
-      <!-- Work around focus ring not showing properly. -->
-      <spacer style="width: 1em;"/>
-      <checkbox label="&doNotTrackCheckbox2.label;"
-                accesskey="&doNotTrackCheckbox2.accesskey;"
-                preference="privacy.donottrackheader.enabled"/>
-    </hbox>
-    <description flex="1" class="doNotTrackLearnMore">
-      &doNotTrackTPInfo.description;
-      <label class="text-link"
-             href="https://www.mozilla.org/dnt">&doNotTrackLearnMore.label;</label>
-    </description>
-  </prefpane>
-</prefwindow>
--- a/browser/components/preferences/in-content/privacy.js
+++ b/browser/components/preferences/in-content/privacy.js
@@ -619,24 +619,16 @@ var gPrivacyPane = {
       brandShortName: brandName,
       windowTitle: bundlePreferences.getString("blockliststitle"),
       introText: bundlePreferences.getString("blockliststext")
     };
     gSubDialog.open("chrome://browser/content/preferences/blocklists.xul",
       null, params);
   },
 
-  /**
-   * Displays the Do Not Track settings dialog.
-   */
-  showDoNotTrackSettings() {
-    gSubDialog.open("chrome://browser/content/preferences/donottrack.xul",
-      "resizable=no");
-  },
-
   // HISTORY
 
   /*
    * Preferences:
    *
    * places.history.enabled
    * - whether history is enabled or not
    * browser.formfill.enable
--- a/browser/components/preferences/jar.mn
+++ b/browser/components/preferences/jar.mn
@@ -7,17 +7,16 @@ browser.jar:
     content/browser/preferences/applicationManager.js
     content/browser/preferences/blocklists.xul
     content/browser/preferences/blocklists.js
 *   content/browser/preferences/colors.xul
 *   content/browser/preferences/cookies.xul
     content/browser/preferences/cookies.js
 *   content/browser/preferences/connection.xul
     content/browser/preferences/connection.js
-    content/browser/preferences/donottrack.xul
 *   content/browser/preferences/fonts.xul
     content/browser/preferences/fonts.js
     content/browser/preferences/handlers.xml
     content/browser/preferences/handlers.css
 *   content/browser/preferences/languages.xul
     content/browser/preferences/languages.js
     content/browser/preferences/permissions.xul
     content/browser/preferences/sitePermissions.xul
--- a/browser/components/sessionstore/test/unit/head.js
+++ b/browser/components/sessionstore/test/unit/head.js
@@ -2,20 +2,20 @@ var Cu = Components.utils;
 var Cc = Components.classes;
 var Ci = Components.interfaces;
 
 Components.utils.import("resource://gre/modules/Services.jsm");
 const {OS} = Cu.import("resource://gre/modules/osfile.jsm", {});
 
 // Call a function once initialization of SessionStartup is complete
 function afterSessionStartupInitialization(cb) {
-  do_print("Waiting for session startup initialization");
+  info("Waiting for session startup initialization");
   let observer = function() {
     try {
-      do_print("Session startup initialization observed");
+      info("Session startup initialization observed");
       Services.obs.removeObserver(observer, "sessionstore-state-finalized");
       cb();
     } catch (ex) {
       do_throw(ex);
     }
   };
 
   // We need the Crash Monitor initialized for sessionstartup to run
--- a/browser/components/sessionstore/test/unit/test_backup_once.js
+++ b/browser/components/sessionstore/test/unit/test_backup_once.js
@@ -34,26 +34,26 @@ add_task(async function init() {
 });
 
 var pathStore;
 var pathBackup;
 var decoder;
 
 function promise_check_exist(path, shouldExist) {
   return (async function() {
-    do_print("Ensuring that " + path + (shouldExist ? " exists" : " does not exist"));
+    info("Ensuring that " + path + (shouldExist ? " exists" : " does not exist"));
     if ((await OS.File.exists(path)) != shouldExist) {
       throw new Error("File " + path + " should " + (shouldExist ? "exist" : "not exist"));
     }
   })();
 }
 
 function promise_check_contents(path, expect) {
   return (async function() {
-    do_print("Checking whether " + path + " has the right contents");
+    info("Checking whether " + path + " has the right contents");
     let actual = await OS.File.read(path, { encoding: "utf-8", compression: "lz4" });
     Assert.deepEqual(JSON.parse(actual), expect, `File ${path} contains the expected data.`);
   })();
 }
 
 function generateFileContents(id) {
   let url = `http://example.com/test_backup_once#${id}_${Math.random()}`;
   return {windows: [{tabs: [{entries: [{url}], index: 1}]}]};
@@ -61,24 +61,24 @@ function generateFileContents(id) {
 
 // Write to the store, and check that it creates:
 // - $Path.recovery with the new data
 // - $Path.nextUpgradeBackup with the old data
 add_task(async function test_first_write_backup() {
   let initial_content = generateFileContents("initial");
   let new_content = generateFileContents("test_1");
 
-  do_print("Before the first write, none of the files should exist");
+  info("Before the first write, none of the files should exist");
   await promise_check_exist(Paths.backups, false);
 
   await File.makeDir(Paths.backups);
   await File.writeAtomic(Paths.clean, JSON.stringify(initial_content), { encoding: "utf-8", compression: "lz4" });
   await SessionFile.write(new_content);
 
-  do_print("After first write, a few files should have been created");
+  info("After first write, a few files should have been created");
   await promise_check_exist(Paths.backups, true);
   await promise_check_exist(Paths.clean, false);
   await promise_check_exist(Paths.cleanBackup, true);
   await promise_check_exist(Paths.recovery, true);
   await promise_check_exist(Paths.recoveryBackup, false);
   await promise_check_exist(Paths.nextUpgradeBackup, true);
 
   await promise_check_contents(Paths.recovery, new_content);
@@ -113,12 +113,12 @@ add_task(async function test_second_writ
 add_task(async function test_shutdown() {
   let output = generateFileContents("test_3");
 
   await File.writeAtomic(Paths.recovery, "I should disappear");
   await File.writeAtomic(Paths.recoveryBackup, "I should also disappear");
 
   await SessionWorker.post("write", [output, { isFinalWrite: true, performShutdownCleanup: true}]);
 
-  do_check_false((await File.exists(Paths.recovery)));
-  do_check_false((await File.exists(Paths.recoveryBackup)));
+  Assert.equal(false, (await File.exists(Paths.recovery)));
+  Assert.equal(false, (await File.exists(Paths.recoveryBackup)));
   await promise_check_contents(Paths.clean, output);
 });
--- a/browser/components/sessionstore/test/unit/test_migration_lz4compression.js
+++ b/browser/components/sessionstore/test/unit/test_migration_lz4compression.js
@@ -12,26 +12,26 @@ updateAppInfo({
   name: "SessionRestoreTest",
   ID: "{230de50e-4cd1-11dc-8314-0800200c9a66}",
   version: "1",
   platformVersion: "",
 });
 
 function promise_check_exist(path, shouldExist) {
   return (async function() {
-    do_print("Ensuring that " + path + (shouldExist ? " exists" : " does not exist"));
+    info("Ensuring that " + path + (shouldExist ? " exists" : " does not exist"));
     if ((await OS.File.exists(path)) != shouldExist) {
       throw new Error("File " + path + " should " + (shouldExist ? "exist" : "not exist"));
     }
   })();
 }
 
 function promise_check_contents(path, expect) {
   return (async function() {
-    do_print("Checking whether " + path + " has the right contents");
+    info("Checking whether " + path + " has the right contents");
     let actual = await OS.File.read(path, { encoding: "utf-8", compression: "lz4" });
     Assert.deepEqual(JSON.parse(actual), expect, `File ${path} contains the expected data.`);
   })();
 }
 
 function generateFileContents(id) {
   let url = `http://example.com/test_backup_once#${id}_${Math.random()}`;
   return {windows: [{tabs: [{entries: [{url}], index: 1}]}]};
--- a/browser/components/sessionstore/test/unit/test_shutdown_cleanup.js
+++ b/browser/components/sessionstore/test/unit/test_shutdown_cleanup.js
@@ -32,17 +32,17 @@ add_task(async function setup() {
   let source = do_get_file("data/sessionstore_valid.js");
   source.copyTo(profd, "sessionstore.js");
   await writeCompressedFile(Paths.clean.replace("jsonlz4", "js"), Paths.clean);
 
   // Finish SessionFile initialization.
   await SessionFile.read();
 
   // Reset prefs on cleanup.
-  do_register_cleanup(() => {
+  registerCleanupFunction(() => {
     Services.prefs.clearUserPref("browser.sessionstore.max_serialize_back");
     Services.prefs.clearUserPref("browser.sessionstore.max_serialize_forward");
   });
 });
 
 function createSessionState(index) {
   // Generate the tab state entries and set the one-based
   // tab-state index to the middle session history entry.
--- a/browser/components/sessionstore/test/unit/test_startup_invalid_session.js
+++ b/browser/components/sessionstore/test/unit/test_startup_invalid_session.js
@@ -14,15 +14,15 @@ function run_test() {
   // Compress sessionstore.js to sessionstore.jsonlz4
   // and remove sessionstore.js
   let oldExtSessionFile = SessionFile.Paths.clean.replace("jsonlz4", "js");
   writeCompressedFile(oldExtSessionFile, SessionFile.Paths.clean).then(() => {
     let startup = Cc["@mozilla.org/browser/sessionstartup;1"].
         getService(Ci.nsISessionStartup);
 
     afterSessionStartupInitialization(function cb() {
-      do_check_eq(startup.sessionType, Ci.nsISessionStartup.NO_SESSION);
+      Assert.equal(startup.sessionType, Ci.nsISessionStartup.NO_SESSION);
       do_test_finished();
     });
   });
 
   do_test_pending();
 }
--- a/browser/components/sessionstore/test/unit/test_startup_nosession_async.js
+++ b/browser/components/sessionstore/test/unit/test_startup_nosession_async.js
@@ -11,12 +11,12 @@ function run_test() {
   do_get_profile();
   // Initialize the profile (the session startup uses it)
 
   do_test_pending();
   let startup = Cc["@mozilla.org/browser/sessionstartup;1"].
     getService(Ci.nsISessionStartup);
 
   afterSessionStartupInitialization(function cb() {
-    do_check_eq(startup.sessionType, Ci.nsISessionStartup.NO_SESSION);
+    Assert.equal(startup.sessionType, Ci.nsISessionStartup.NO_SESSION);
     do_test_finished();
   });
 }
--- a/browser/components/sessionstore/test/unit/test_startup_session_async.js
+++ b/browser/components/sessionstore/test/unit/test_startup_session_async.js
@@ -20,15 +20,15 @@ function run_test() {
   // Compress sessionstore.js to sessionstore.jsonlz4
   // and remove sessionstore.js
   let oldExtSessionFile = SessionFile.Paths.clean.replace("jsonlz4", "js");
   writeCompressedFile(oldExtSessionFile, SessionFile.Paths.clean).then(() => {
     let startup = Cc["@mozilla.org/browser/sessionstartup;1"].
         getService(Ci.nsISessionStartup);
 
     afterSessionStartupInitialization(function cb() {
-      do_check_eq(startup.sessionType, Ci.nsISessionStartup.DEFER_SESSION);
+      Assert.equal(startup.sessionType, Ci.nsISessionStartup.DEFER_SESSION);
       do_test_finished();
     });
   });
 
   do_test_pending();
 }
--- a/browser/components/shell/test/unit/test_421977.js
+++ b/browser/components/shell/test/unit/test_421977.js
@@ -40,30 +40,30 @@ function hexToColor(aString) {
  * result in the Shell component returning a background color equals
  * to aExpectedShellColor in #RRGGBB format.
  */
 function checkGConfToShellColor(aGConfColor, aExpectedShellColor) {
 
   gGConf.setString(GCONF_BG_COLOR_KEY, aGConfColor);
   var shellColor = colorToHex(gShell.desktopBackgroundColor);
 
-  do_check_eq(shellColor, aExpectedShellColor);
+  Assert.equal(shellColor, aExpectedShellColor);
 }
 
 /**
  * Checks that setting the background color (in #RRGGBB format) using the Shell
  * component will result in having a GConf key for the background color set to
  * aExpectedGConfColor.
  */
 function checkShellToGConfColor(aShellColor, aExpectedGConfColor) {
 
   gShell.desktopBackgroundColor = hexToColor(aShellColor);
   var gconfColor = gGConf.getString(GCONF_BG_COLOR_KEY);
 
-  do_check_eq(gconfColor, aExpectedGConfColor);
+  Assert.equal(gconfColor, aExpectedGConfColor);
 }
 
 function run_test() {
 
   // This test is Linux specific for now
   if (!("@mozilla.org/gnome-gconf-service;1" in Cc))
     return;
 
--- a/browser/components/tests/unit/test_browserGlue_migration_loop_cleanup.js
+++ b/browser/components/tests/unit/test_browserGlue_migration_loop_cleanup.js
@@ -19,14 +19,14 @@ add_task(async function test_check_clean
                 /NS_ERROR_UNEXPECTED/,
                 "should have cleared old loop preference 'loop.createdRoom'");
   Assert.ok(Services.prefs.getBoolPref("loop1.createdRoom"),
             "should have left non-loop pref 'loop1.createdRoom' untouched");
   Assert.ok(Services.prefs.getBoolPref("loo.createdRoom"),
             "should have left non-loop pref 'loo.createdRoom' untouched");
 });
 
-do_register_cleanup(() => {
+registerCleanupFunction(() => {
   Services.prefs.clearUserPref("browser.migration.version");
   Services.prefs.clearUserPref("loop.createdRoom");
   Services.prefs.clearUserPref("loop1.createdRoom");
   Services.prefs.clearUserPref("loo.createdRoom");
 });
--- a/browser/components/tests/unit/test_distribution.js
+++ b/browser/components/tests/unit/test_distribution.js
@@ -74,17 +74,17 @@ function run_test() {
   testDistributionFile.copyTo(distroDir, "distribution.ini");
   Assert.ok(testDistributionFile.exists());
 
   installDistributionEngine();
 
   run_next_test();
 }
 
-do_register_cleanup(function() {
+registerCleanupFunction(function() {
   // Remove the distribution dir, even if the test failed, otherwise all
   // next tests will use it.
   let distDir = gProfD.clone();
   distDir.append("distribution");
   distDir.remove(true);
   Assert.ok(!distDir.exists());
   Services.prefs.clearUserPref("distribution.testing.loadFromProfile");
 });
--- a/browser/components/tests/unit/test_distribution_cachedexistence.js
+++ b/browser/components/tests/unit/test_distribution_cachedexistence.js
@@ -107,12 +107,12 @@ function deleteDistribution() {
   iniFile.remove(false);
 }
 
 function setupTest() {
   // Set special pref to load distribution.ini from the profile folder.
   Services.prefs.setBoolPref(PREF_LOAD_FROM_PROFILE, true);
 }
 
-do_register_cleanup(function() {
+registerCleanupFunction(function() {
   deleteDistribution();
   Services.prefs.clearUserPref(PREF_LOAD_FROM_PROFILE);
 });
--- a/browser/experiments/test/xpcshell/test_activate.js
+++ b/browser/experiments/test/xpcshell/test_activate.js
@@ -28,17 +28,17 @@ add_task(async function test_setup() {
   loadAddonManager();
   gPolicy = new Experiments.Policy();
 
   gHttpServer = new HttpServer();
   gHttpServer.start(-1);
   let port = gHttpServer.identity.primaryPort;
   gHttpRoot = "http://localhost:" + port + "/";
   gHttpServer.registerDirectory("/", do_get_cwd());
-  do_register_cleanup(() => gHttpServer.stop(() => {}));
+  registerCleanupFunction(() => gHttpServer.stop(() => {}));
 
   patchPolicy(gPolicy, {
     updatechannel: () => "nightly",
   });
 
   Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
   Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
   Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
--- a/browser/experiments/test/xpcshell/test_api.js
+++ b/browser/experiments/test/xpcshell/test_api.js
@@ -50,17 +50,17 @@ add_task(async function test_setup() {
   gManifestHandlerURI = gHttpRoot + MANIFEST_HANDLER;
   gHttpServer.registerDirectory("/data/", do_get_cwd());
   gHttpServer.registerPathHandler("/" + MANIFEST_HANDLER, (request, response) => {
     response.setStatusLine(null, 200, "OK");
     response.write(JSON.stringify(gManifestObject));
     response.processAsync();
     response.finish();
   });
-  do_register_cleanup(() => gHttpServer.stop(() => {}));
+  registerCleanupFunction(() => gHttpServer.stop(() => {}));
 
   Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
   Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
   Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
   Services.prefs.setCharPref(PREF_MANIFEST_URI, gManifestHandlerURI);
   Services.prefs.setIntPref(PREF_FETCHINTERVAL, 0);
 
   gPolicy = new Experiments.Policy();
--- a/browser/experiments/test/xpcshell/test_cache.js
+++ b/browser/experiments/test/xpcshell/test_cache.js
@@ -31,17 +31,17 @@ add_task(async function test_setup() {
   gManifestHandlerURI = gHttpRoot + MANIFEST_HANDLER;
   gHttpServer.registerDirectory("/data/", do_get_cwd());
   gHttpServer.registerPathHandler("/" + MANIFEST_HANDLER, (request, response) => {
     response.setStatusLine(null, 200, "OK");
     response.write(JSON.stringify(gManifestObject));
     response.processAsync();
     response.finish();
   });
-  do_register_cleanup(() => gHttpServer.stop(() => {}));
+  registerCleanupFunction(() => gHttpServer.stop(() => {}));
 
   Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
   Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
   Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
   Services.prefs.setCharPref(PREF_MANIFEST_URI, gManifestHandlerURI);
   Services.prefs.setIntPref(PREF_FETCHINTERVAL, 0);
 
   gPolicy = new Experiments.Policy();
--- a/browser/experiments/test/xpcshell/test_cacherace.js
+++ b/browser/experiments/test/xpcshell/test_cacherace.js
@@ -31,17 +31,17 @@ add_task(async function test_setup() {
   gManifestHandlerURI = gHttpRoot + MANIFEST_HANDLER;
   gHttpServer.registerDirectory("/data/", do_get_cwd());
   gHttpServer.registerPathHandler("/" + MANIFEST_HANDLER, (request, response) => {
     response.setStatusLine(null, 200, "OK");
     response.write(JSON.stringify(gManifestObject));
     response.processAsync();
     response.finish();
   });
-  do_register_cleanup(() => gHttpServer.stop(() => {}));
+  registerCleanupFunction(() => gHttpServer.stop(() => {}));
 
   Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
   Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
   Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
   Services.prefs.setCharPref(PREF_MANIFEST_URI, gManifestHandlerURI);
   Services.prefs.setIntPref(PREF_FETCHINTERVAL, 0);
 
   let ExperimentsScope = Cu.import("resource:///modules/experiments/Experiments.jsm", {});
@@ -78,17 +78,17 @@ add_task(async function test_setup() {
         appName: ["XPCShell"],
         channel: ["nightly"],
         startTime: dateToSeconds(futureDate(now, -MS_IN_ONE_DAY)),
         endTime: dateToSeconds(futureDate(now, MS_IN_ONE_DAY)),
       },
     ],
   };
 
-  do_print("gManifestObject: " + JSON.stringify(gManifestObject));
+  info("gManifestObject: " + JSON.stringify(gManifestObject));
 
   // In order for the addon manager to work properly, we hack
   // Experiments.instance which is used by the XPIProvider
   let experiments = new Experiments.Experiments(gPolicy);
   Assert.strictEqual(ExperimentsScope.gExperiments, null);
   ExperimentsScope.gExperiments = experiments;
 
   await experiments.updateManifest();
--- a/browser/experiments/test/xpcshell/test_disableExperiments.js
+++ b/browser/experiments/test/xpcshell/test_disableExperiments.js
@@ -32,17 +32,17 @@ add_task(async function test_setup() {
   gManifestHandlerURI = gHttpRoot + MANIFEST_HANDLER;
   gHttpServer.registerDirectory("/data/", do_get_cwd());
   gHttpServer.registerPathHandler("/" + MANIFEST_HANDLER, (request, response) => {
     response.setStatusLine(null, 200, "OK");
     response.write(JSON.stringify(gManifestObject));
     response.processAsync();
     response.finish();
   });
-  do_register_cleanup(() => gHttpServer.stop(() => {}));
+  registerCleanupFunction(() => gHttpServer.stop(() => {}));
 
   Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
   Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
   Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
   Services.prefs.setCharPref(PREF_MANIFEST_URI, gManifestHandlerURI);
   Services.prefs.setIntPref(PREF_FETCHINTERVAL, 0);
 
   gPolicy = new Experiments.Policy();
--- a/browser/experiments/test/xpcshell/test_fetch.js
+++ b/browser/experiments/test/xpcshell/test_fetch.js
@@ -15,17 +15,17 @@ var gPolicy     = new Experiments.Policy
 function run_test() {
   loadAddonManager();
 
   gHttpServer = new HttpServer();
   gHttpServer.start(-1);
   let port = gHttpServer.identity.primaryPort;
   gHttpRoot = "http://localhost:" + port + "/";
   gHttpServer.registerDirectory("/", do_get_cwd());
-  do_register_cleanup(() => gHttpServer.stop(() => {}));
+  registerCleanupFunction(() => gHttpServer.stop(() => {}));
 
   Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
   Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
   Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
 
   patchPolicy(gPolicy, {
     updatechannel: () => "nightly",
   });
--- a/browser/experiments/test/xpcshell/test_nethang_bug1012924.js
+++ b/browser/experiments/test/xpcshell/test_nethang_bug1012924.js
@@ -19,17 +19,17 @@ add_task(async function test_setup() {
   let handlerURI = httpRoot + MANIFEST_HANDLER;
   httpServer.registerPathHandler("/" + MANIFEST_HANDLER,
     (request, response) => {
       response.processAsync();
       response.setStatus(null, 200, "OK");
       response.write("["); // never finish!
     });
 
-  do_register_cleanup(() => httpServer.stop(() => {}));
+  registerCleanupFunction(() => httpServer.stop(() => {}));
   Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
   Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
   Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
   Services.prefs.setCharPref(PREF_MANIFEST_URI, handlerURI);
   Services.prefs.setIntPref(PREF_FETCHINTERVAL, 0);
 
   let experiments = Experiments.instance();
   experiments.updateManifest().then(
--- a/browser/experiments/test/xpcshell/test_previous_provider.js
+++ b/browser/experiments/test/xpcshell/test_previous_provider.js
@@ -21,17 +21,17 @@ add_task(function test_setup() {
   gDataRoot = httpRoot + "data/";
   gHttpServer.registerDirectory("/data/", do_get_cwd());
   gHttpServer.registerPathHandler("/manifests/handler", (req, res) => {
     res.setStatusLine(null, 200, "OK");
     res.write(JSON.stringify(gManifestObject));
     res.processAsync();
     res.finish();
   });
-  do_register_cleanup(() => gHttpServer.stop(() => {}));
+  registerCleanupFunction(() => gHttpServer.stop(() => {}));
 
   Services.prefs.setBoolPref("experiments.enabled", true);
   Services.prefs.setCharPref("experiments.manifest.uri",
                              httpRoot + "manifests/handler");
   Services.prefs.setBoolPref("experiments.logging.dump", true);
   Services.prefs.setCharPref("experiments.logging.level", "Trace");
 });
 
--- a/browser/experiments/test/xpcshell/test_telemetry.js
+++ b/browser/experiments/test/xpcshell/test_telemetry.js
@@ -19,17 +19,17 @@ var gHttpRoot            = null;
 var gDataRoot            = null;
 var gPolicy              = null;
 var gManifestObject      = null;
 var gManifestHandlerURI  = null;
 
 const TLOG = TELEMETRY_LOG;
 
 function checkEvent(event, id, data) {
-  do_print("Checking message " + id);
+  info("Checking message " + id);
   Assert.equal(event[0], id, "id should match");
   Assert.ok(event[1] > 0, "timestamp should be greater than 0");
 
   if (data === undefined) {
    Assert.equal(event.length, 2, "event array should have 2 entries");
   } else {
     Assert.equal(event.length, data.length + 2, "event entry count should match expected count");
     for (var i = 0; i < data.length; ++i) {
@@ -50,17 +50,17 @@ add_task(async function test_setup() {
   gManifestHandlerURI = gHttpRoot + MANIFEST_HANDLER;
   gHttpServer.registerDirectory("/data/", do_get_cwd());
   gHttpServer.registerPathHandler("/" + MANIFEST_HANDLER, (request, response) => {
     response.setStatusLine(null, 200, "OK");
     response.write(JSON.stringify(gManifestObject));
     response.processAsync();
     response.finish();
   });
-  do_register_cleanup(() => gHttpServer.stop(() => {}));
+  registerCleanupFunction(() => gHttpServer.stop(() => {}));
 
   Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
   Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
   Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
   Services.prefs.setCharPref(PREF_MANIFEST_URI, gManifestHandlerURI);
   Services.prefs.setIntPref(PREF_FETCHINTERVAL, 0);
 
   gPolicy = new Experiments.Policy();
@@ -126,17 +126,17 @@ add_task(async function test_telemetryBa
   defineNow(gPolicy, now);
 
   await experiments.updateManifest();
   let list = await experiments.getExperiments();
   Assert.equal(list.length, 0, "Experiment list should be empty.");
 
   expectedLogLength += 2;
   let log = TelemetryLog.entries();
-  do_print("Telemetry log: " + JSON.stringify(log));
+  info("Telemetry log: " + JSON.stringify(log));
   Assert.equal(log.length, expectedLogLength, "Telemetry log should have " + expectedLogLength + " entries.");
   checkEvent(log[log.length - 2], TLOG.ACTIVATION_KEY,
              [TLOG.ACTIVATION.REJECTED, EXPERIMENT1_ID, "startTime"]);
   checkEvent(log[log.length - 1], TLOG.ACTIVATION_KEY,
              [TLOG.ACTIVATION.REJECTED, EXPERIMENT2_ID, "startTime"]);
 
   // Trigger update, clock set for experiment 1 to start.
 
--- a/browser/extensions/formautofill/test/unit/head.js
+++ b/browser/extensions/formautofill/test/unit/head.js
@@ -66,29 +66,29 @@ async function initProfileStorage(fileNa
 
   if (!records || !Array.isArray(records)) {
     return profileStorage;
   }
 
   let onChanged = TestUtils.topicObserved("formautofill-storage-changed",
                                           (subject, data) => data == "add");
   for (let record of records) {
-    do_check_true(profileStorage[collectionName].add(record));
+    Assert.ok(profileStorage[collectionName].add(record));
     await onChanged;
   }
   await profileStorage._saveImmediately();
   return profileStorage;
 }
 
 function verifySectionFieldDetails(sections, expectedResults) {
   Assert.equal(sections.length, expectedResults.length, "Expected section count.");
   sections.forEach((sectionInfo, sectionIndex) => {
     let expectedSectionInfo = expectedResults[sectionIndex];
-    do_print("FieldName Prediction Results: " + sectionInfo.map(i => i.fieldName));
-    do_print("FieldName Expected Results:   " + expectedSectionInfo.map(i => i.fieldName));
+    info("FieldName Prediction Results: " + sectionInfo.map(i => i.fieldName));
+    info("FieldName Expected Results:   " + expectedSectionInfo.map(i => i.fieldName));
     Assert.equal(sectionInfo.length, expectedSectionInfo.length, "Expected field count.");
 
     sectionInfo.forEach((field, fieldIndex) => {
       let expectedField = expectedSectionInfo[fieldIndex];
       delete field._reason;
       delete field.elementWeakRef;
       Assert.deepEqual(field, expectedField);
     });
@@ -96,17 +96,17 @@ function verifySectionFieldDetails(secti
 }
 
 function runHeuristicsTest(patterns, fixturePathPrefix) {
   Cu.import("resource://formautofill/FormAutofillHeuristics.jsm");
   Cu.import("resource://formautofill/FormAutofillUtils.jsm");
 
   patterns.forEach(testPattern => {
     add_task(async function() {
-      do_print("Starting test fixture: " + testPattern.fixturePath);
+      info("Starting test fixture: " + testPattern.fixturePath);
       let file = do_get_file(fixturePathPrefix + testPattern.fixturePath);
       let doc = MockDocument.createTestDocumentFromFile("http://localhost:8080/test/", file);
 
       let forms = [];
 
       for (let field of FormAutofillUtils.autofillFieldSelector(doc)) {
         let formLike = FormLikeFactory.createFromField(field);
         if (!forms.some(form => form.rootElement === formLike.rootElement)) {
@@ -175,16 +175,16 @@ function objectMatches(object, fields) {
 add_task(async function head_initialize() {
   Services.prefs.setStringPref("extensions.formautofill.available", "on");
   Services.prefs.setBoolPref("extensions.formautofill.creditCards.available", true);
   Services.prefs.setBoolPref("extensions.formautofill.heuristics.enabled", true);
   Services.prefs.setBoolPref("extensions.formautofill.section.enabled", true);
   Services.prefs.setBoolPref("dom.forms.autocomplete.formautofill", true);
 
   // Clean up after every test.
-  do_register_cleanup(function head_cleanup() {
+  registerCleanupFunction(function head_cleanup() {
     Services.prefs.clearUserPref("extensions.formautofill.available");
     Services.prefs.clearUserPref("extensions.formautofill.creditCards.available");
     Services.prefs.clearUserPref("extensions.formautofill.heuristics.enabled");
     Services.prefs.clearUserPref("extensions.formautofill.section.enabled");
     Services.prefs.clearUserPref("dom.forms.autocomplete.formautofill");
   });
 });
--- a/browser/extensions/formautofill/test/unit/test_activeStatus.js
+++ b/browser/extensions/formautofill/test/unit/test_activeStatus.js
@@ -7,101 +7,101 @@
 let {FormAutofillParent} = Cu.import("resource://formautofill/FormAutofillParent.jsm", {});
 Cu.import("resource://formautofill/ProfileStorage.jsm");
 
 add_task(async function test_activeStatus_init() {
   let formAutofillParent = new FormAutofillParent();
   sinon.spy(formAutofillParent, "_updateStatus");
 
   // Default status is null before initialization
-  do_check_eq(formAutofillParent._active, null);
-  do_check_eq(Services.ppmm.initialProcessData.autofillEnabled, undefined);
+  Assert.equal(formAutofillParent._active, null);
+  Assert.equal(Services.ppmm.initialProcessData.autofillEnabled, undefined);
 
   await formAutofillParent.init();
   // init shouldn't call updateStatus since that requires storage which will
   // lead to startup time regressions.
-  do_check_eq(formAutofillParent._updateStatus.called, false);
-  do_check_eq(Services.ppmm.initialProcessData.autofillEnabled, undefined);
+  Assert.equal(formAutofillParent._updateStatus.called, false);
+  Assert.equal(Services.ppmm.initialProcessData.autofillEnabled, undefined);
 
   // Initialize profile storage
   await formAutofillParent.profileStorage.initialize();
   // Upon first initializing profile storage, status should be computed.
-  do_check_eq(formAutofillParent._updateStatus.called, true);
-  do_check_eq(Services.ppmm.initialProcessData.autofillEnabled, false);
+  Assert.equal(formAutofillParent._updateStatus.called, true);
+  Assert.equal(Services.ppmm.initialProcessData.autofillEnabled, false);
 
   formAutofillParent._uninit();
 });
 
 add_task(async function test_activeStatus_observe() {
   let formAutofillParent = new FormAutofillParent();
   sinon.stub(formAutofillParent, "_computeStatus");
   sinon.spy(formAutofillParent, "_onStatusChanged");
 
   // _active = _computeStatus() => No need to trigger _onStatusChanged
   formAutofillParent._active = true;
   formAutofillParent._computeStatus.returns(true);
   formAutofillParent.observe(null, "nsPref:changed", "extensions.formautofill.addresses.enabled");
   formAutofillParent.observe(null, "nsPref:changed", "extensions.formautofill.creditCards.enabled");
-  do_check_eq(formAutofillParent._onStatusChanged.called, false);
+  Assert.equal(formAutofillParent._onStatusChanged.called, false);
 
   // _active != _computeStatus() => Need to trigger _onStatusChanged
   formAutofillParent._computeStatus.returns(false);
   formAutofillParent._onStatusChanged.reset();
   formAutofillParent.observe(null, "nsPref:changed", "extensions.formautofill.addresses.enabled");
   formAutofillParent.observe(null, "nsPref:changed", "extensions.formautofill.creditCards.enabled");
-  do_check_eq(formAutofillParent._onStatusChanged.called, true);
+  Assert.equal(formAutofillParent._onStatusChanged.called, true);
 
   // profile changed => Need to trigger _onStatusChanged
   ["add", "update", "remove", "reconcile"].forEach(event => {
     formAutofillParent._computeStatus.returns(!formAutofillParent._active);
     formAutofillParent._onStatusChanged.reset();
     formAutofillParent.observe(null, "formautofill-storage-changed", event);
-    do_check_eq(formAutofillParent._onStatusChanged.called, true);
+    Assert.equal(formAutofillParent._onStatusChanged.called, true);
   });
 
   // profile metadata updated => No need to trigger _onStatusChanged
   formAutofillParent._computeStatus.returns(!formAutofillParent._active);
   formAutofillParent._onStatusChanged.reset();
   formAutofillParent.observe(null, "formautofill-storage-changed", "notifyUsed");
-  do_check_eq(formAutofillParent._onStatusChanged.called, false);
+  Assert.equal(formAutofillParent._onStatusChanged.called, false);
 });
 
 add_task(async function test_activeStatus_computeStatus() {
   let formAutofillParent = new FormAutofillParent();
-  do_register_cleanup(function cleanup() {
+  registerCleanupFunction(function cleanup() {
     Services.prefs.clearUserPref("extensions.formautofill.addresses.enabled");
     Services.prefs.clearUserPref("extensions.formautofill.creditCards.enabled");
   });
 
   sinon.stub(profileStorage.addresses, "getAll");
   profileStorage.addresses.getAll.returns([]);
 
   // pref is enabled and profile is empty.
   Services.prefs.setBoolPref("extensions.formautofill.addresses.enabled", true);
   Services.prefs.setBoolPref("extensions.formautofill.creditCards.enabled", true);
-  do_check_eq(formAutofillParent._computeStatus(), false);
+  Assert.equal(formAutofillParent._computeStatus(), false);
 
   // pref is disabled and profile is empty.
   Services.prefs.setBoolPref("extensions.formautofill.addresses.enabled", false);
   Services.prefs.setBoolPref("extensions.formautofill.creditCards.enabled", false);
-  do_check_eq(formAutofillParent._computeStatus(), false);
+  Assert.equal(formAutofillParent._computeStatus(), false);
 
   profileStorage.addresses.getAll.returns([{"given-name": "John"}]);
   formAutofillParent.observe(null, "formautofill-storage-changed", "add");
   // pref is enabled and profile is not empty.
   Services.prefs.setBoolPref("extensions.formautofill.addresses.enabled", true);
   Services.prefs.setBoolPref("extensions.formautofill.addresses.enabled", true);
-  do_check_eq(formAutofillParent._computeStatus(), true);
+  Assert.equal(formAutofillParent._computeStatus(), true);
 
   // pref is partial enabled and profile is not empty.
   Services.prefs.setBoolPref("extensions.formautofill.addresses.enabled", true);
   Services.prefs.setBoolPref("extensions.formautofill.creditCards.enabled", false);
-  do_check_eq(formAutofillParent._computeStatus(), true);
+  Assert.equal(formAutofillParent._computeStatus(), true);
   Services.prefs.setBoolPref("extensions.formautofill.addresses.enabled", false);
   Services.prefs.setBoolPref("extensions.formautofill.creditCards.enabled", true);
-  do_check_eq(formAutofillParent._computeStatus(), true);
+  Assert.equal(formAutofillParent._computeStatus(), true);
 
 
   // pref is disabled and profile is not empty.
   Services.prefs.setBoolPref("extensions.formautofill.addresses.enabled", false);
   Services.prefs.setBoolPref("extensions.formautofill.creditCards.enabled", false);
-  do_check_eq(formAutofillParent._computeStatus(), false);
+  Assert.equal(formAutofillParent._computeStatus(), false);
 });
--- a/browser/extensions/formautofill/test/unit/test_addressDataLoader.js
+++ b/browser/extensions/formautofill/test/unit/test_addressDataLoader.js
@@ -60,17 +60,17 @@ add_task(async function test_loadDataSta
   undefinedMetadata = FormAutofillUtils.getCountryAddressData("US", "AS");
   Assert.equal(undefinedMetadata, undefined, "metadata should be undefined");
   // _loadScripts should not be called
   sinon.assert.notCalled(AddressDataLoader._loadScripts);
 });
 
 SUPPORT_COUNTRIES_TESTCASES.forEach(testcase => {
   add_task(async function test_support_country() {
-    do_print("Starting testcase: Check " + testcase.country + " metadata");
+    info("Starting testcase: Check " + testcase.country + " metadata");
     let metadata = FormAutofillUtils.getCountryAddressData(testcase.country);
     Assert.ok(testcase.properties.every(key => metadata[key]),
               "These properties should exist: " + testcase.properties);
     // Verify the multi-locale country
     if (metadata.languages && metadata.languages.length > 1) {
       let locales = FormAutofillUtils.getCountryAddressDataWithLocales(testcase.country);
       Assert.equal(metadata.languages.length, locales.length, "Total supported locales should be matched");
       metadata.languages.forEach((lang, index) => {
--- a/browser/extensions/formautofill/test/unit/test_addressRecords.js
+++ b/browser/extensions/formautofill/test/unit/test_addressRecords.js
@@ -250,25 +250,25 @@ const MERGE_TESTCASES = [
       "tel": "+16509030800",
       country: "US",
     },
   },
 ];
 
 let do_check_record_matches = (recordWithMeta, record) => {
   for (let key in record) {
-    do_check_eq(recordWithMeta[key], record[key]);
+    Assert.equal(recordWithMeta[key], record[key]);
   }
 };
 
 add_task(async function test_initialize() {
   let profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME);
 
-  do_check_eq(profileStorage._store.data.version, 1);
-  do_check_eq(profileStorage._store.data.addresses.length, 0);
+  Assert.equal(profileStorage._store.data.version, 1);
+  Assert.equal(profileStorage._store.data.addresses.length, 0);
 
   let data = profileStorage._store.data;
   Assert.deepEqual(data.addresses, []);
 
   await profileStorage._saveImmediately();
 
   profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME);
 
@@ -280,30 +280,30 @@ add_task(async function test_initialize(
 });
 
 add_task(async function test_getAll() {
   let profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME,
                                                 [TEST_ADDRESS_1, TEST_ADDRESS_2]);
 
   let addresses = profileStorage.addresses.getAll();
 
-  do_check_eq(addresses.length, 2);
+  Assert.equal(addresses.length, 2);
   do_check_record_matches(addresses[0], TEST_ADDRESS_1);
   do_check_record_matches(addresses[1], TEST_ADDRESS_2);
 
   // Check computed fields.
-  do_check_eq(addresses[0].name, "Timothy John Berners-Lee");
-  do_check_eq(addresses[0]["address-line1"], "32 Vassar Street");
-  do_check_eq(addresses[0]["address-line2"], "MIT Room 32-G524");
+  Assert.equal(addresses[0].name, "Timothy John Berners-Lee");
+  Assert.equal(addresses[0]["address-line1"], "32 Vassar Street");
+  Assert.equal(addresses[0]["address-line2"], "MIT Room 32-G524");
 
   // Test with rawData set.
   addresses = profileStorage.addresses.getAll({rawData: true});
-  do_check_eq(addresses[0].name, undefined);
-  do_check_eq(addresses[0]["address-line1"], undefined);
-  do_check_eq(addresses[0]["address-line2"], undefined);
+  Assert.equal(addresses[0].name, undefined);
+  Assert.equal(addresses[0]["address-line1"], undefined);
+  Assert.equal(addresses[0]["address-line2"], undefined);
 
   // Modifying output shouldn't affect the storage.
   addresses[0].organization = "test";
   do_check_record_matches(profileStorage.addresses.getAll()[0], TEST_ADDRESS_1);
 });
 
 add_task(async function test_get() {
   let profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME,
@@ -312,55 +312,55 @@ add_task(async function test_get() {
   let addresses = profileStorage.addresses.getAll();
   let guid = addresses[0].guid;
 
   let address = profileStorage.addresses.get(guid);
   do_check_record_matches(address, TEST_ADDRESS_1);
 
   // Test with rawData set.
   address = profileStorage.addresses.get(guid, {rawData: true});
-  do_check_eq(address.name, undefined);
-  do_check_eq(address["address-line1"], undefined);
-  do_check_eq(address["address-line2"], undefined);
+  Assert.equal(address.name, undefined);
+  Assert.equal(address["address-line1"], undefined);
+  Assert.equal(address["address-line2"], undefined);
 
   // Modifying output shouldn't affect the storage.
   address.organization = "test";
   do_check_record_matches(profileStorage.addresses.get(guid), TEST_ADDRESS_1);
 
-  do_check_eq(profileStorage.addresses.get("INVALID_GUID"), null);
+  Assert.equal(profileStorage.addresses.get("INVALID_GUID"), null);
 });
 
 add_task(async function test_add() {
   let profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME,
                                                 [TEST_ADDRESS_1, TEST_ADDRESS_2]);
 
   let addresses = profileStorage.addresses.getAll();
 
-  do_check_eq(addresses.length, 2);
+  Assert.equal(addresses.length, 2);
 
   do_check_record_matches(addresses[0], TEST_ADDRESS_1);
   do_check_record_matches(addresses[1], TEST_ADDRESS_2);
 
-  do_check_neq(addresses[0].guid, undefined);
-  do_check_eq(addresses[0].version, 1);
-  do_check_neq(addresses[0].timeCreated, undefined);
-  do_check_eq(addresses[0].timeLastModified, addresses[0].timeCreated);
-  do_check_eq(addresses[0].timeLastUsed, 0);
-  do_check_eq(addresses[0].timesUsed, 0);
+  Assert.notEqual(addresses[0].guid, undefined);
+  Assert.equal(addresses[0].version, 1);
+  Assert.notEqual(addresses[0].timeCreated, undefined);
+  Assert.equal(addresses[0].timeLastModified, addresses[0].timeCreated);
+  Assert.equal(addresses[0].timeLastUsed, 0);
+  Assert.equal(addresses[0].timesUsed, 0);
 
   // Empty string should be deleted before saving.
   profileStorage.addresses.add(TEST_ADDRESS_WITH_EMPTY_FIELD);
   let address = profileStorage.addresses._data[2];
-  do_check_eq(address.name, TEST_ADDRESS_WITH_EMPTY_FIELD.name);
-  do_check_eq(address["street-address"], undefined);
+  Assert.equal(address.name, TEST_ADDRESS_WITH_EMPTY_FIELD.name);
+  Assert.equal(address["street-address"], undefined);
 
   // Empty computed fields shouldn't cause any problem.
   profileStorage.addresses.add(TEST_ADDRESS_WITH_EMPTY_COMPUTED_FIELD);
   address = profileStorage.addresses._data[3];
-  do_check_eq(address.email, TEST_ADDRESS_WITH_EMPTY_COMPUTED_FIELD.email);
+  Assert.equal(address.email, TEST_ADDRESS_WITH_EMPTY_COMPUTED_FIELD.email);
 
   Assert.throws(() => profileStorage.addresses.add(TEST_ADDRESS_WITH_INVALID_FIELD),
     /"invalidField" is not a valid field\./);
 
   Assert.throws(() => profileStorage.addresses.add({}),
     /Record contains no valid field\./);
 
   Assert.throws(() => profileStorage.addresses.add(TEST_ADDRESS_EMPTY_AFTER_NORMALIZE),
@@ -376,60 +376,60 @@ add_task(async function test_update() {
   let timeLastModified = addresses[1].timeLastModified;
 
   let onChanged = TestUtils.topicObserved(
     "formautofill-storage-changed",
     (subject, data) =>
       data == "update" && subject.QueryInterface(Ci.nsISupportsString).data == guid
   );
 
-  do_check_neq(addresses[1].country, undefined);
+  Assert.notEqual(addresses[1].country, undefined);
 
   profileStorage.addresses.update(guid, TEST_ADDRESS_3);
   await onChanged;
   await profileStorage._saveImmediately();
 
   profileStorage.addresses.pullSyncChanges(); // force sync metadata, which we check below.
 
   let address = profileStorage.addresses.get(guid, {rawData: true});
 
-  do_check_eq(address.country, undefined);
-  do_check_neq(address.timeLastModified, timeLastModified);
+  Assert.equal(address.country, undefined);
+  Assert.notEqual(address.timeLastModified, timeLastModified);
   do_check_record_matches(address, TEST_ADDRESS_3);
-  do_check_eq(getSyncChangeCounter(profileStorage.addresses, guid), 1);
+  Assert.equal(getSyncChangeCounter(profileStorage.addresses, guid), 1);
 
   // Test preserveOldProperties parameter and field with empty string.
   profileStorage.addresses.update(guid, TEST_ADDRESS_WITH_EMPTY_FIELD, true);
   await onChanged;
   await profileStorage._saveImmediately();
 
   profileStorage.addresses.pullSyncChanges(); // force sync metadata, which we check below.
 
   address = profileStorage.addresses.get(guid, {rawData: true});
 
-  do_check_eq(address["given-name"], "Tim");
-  do_check_eq(address["family-name"], "Berners");
-  do_check_eq(address["street-address"], undefined);
-  do_check_eq(address["postal-code"], "12345");
-  do_check_neq(address.timeLastModified, timeLastModified);
-  do_check_eq(getSyncChangeCounter(profileStorage.addresses, guid), 2);
+  Assert.equal(address["given-name"], "Tim");
+  Assert.equal(address["family-name"], "Berners");
+  Assert.equal(address["street-address"], undefined);
+  Assert.equal(address["postal-code"], "12345");
+  Assert.notEqual(address.timeLastModified, timeLastModified);
+  Assert.equal(getSyncChangeCounter(profileStorage.addresses, guid), 2);
 
   // Empty string should be deleted while updating.
   profileStorage.addresses.update(profileStorage.addresses._data[0].guid, TEST_ADDRESS_WITH_EMPTY_FIELD);
   address = profileStorage.addresses._data[0];
-  do_check_eq(address.name, TEST_ADDRESS_WITH_EMPTY_FIELD.name);
-  do_check_eq(address["street-address"], undefined);
+  Assert.equal(address.name, TEST_ADDRESS_WITH_EMPTY_FIELD.name);
+  Assert.equal(address["street-address"], undefined);
 
   // Empty computed fields shouldn't cause any problem.
   profileStorage.addresses.update(profileStorage.addresses._data[0].guid, TEST_ADDRESS_WITH_EMPTY_COMPUTED_FIELD, false);
   address = profileStorage.addresses._data[0];
-  do_check_eq(address.email, TEST_ADDRESS_WITH_EMPTY_COMPUTED_FIELD.email);
+  Assert.equal(address.email, TEST_ADDRESS_WITH_EMPTY_COMPUTED_FIELD.email);
   profileStorage.addresses.update(profileStorage.addresses._data[1].guid, TEST_ADDRESS_WITH_EMPTY_COMPUTED_FIELD, true);
   address = profileStorage.addresses._data[1];
-  do_check_eq(address.email, TEST_ADDRESS_WITH_EMPTY_COMPUTED_FIELD.email);
+  Assert.equal(address.email, TEST_ADDRESS_WITH_EMPTY_COMPUTED_FIELD.email);
 
   Assert.throws(
     () => profileStorage.addresses.update("INVALID_GUID", TEST_ADDRESS_3),
     /No matching record\./
   );
 
   Assert.throws(
     () => profileStorage.addresses.update(guid, TEST_ADDRESS_WITH_INVALID_FIELD),
@@ -468,156 +468,156 @@ add_task(async function test_notifyUsed(
   let onChanged = TestUtils.topicObserved("formautofill-storage-changed",
                                           (subject, data) => data == "notifyUsed");
 
   profileStorage.addresses.notifyUsed(guid);
   await onChanged;
 
   let address = profileStorage.addresses.get(guid);
 
-  do_check_eq(address.timesUsed, timesUsed + 1);
-  do_check_neq(address.timeLastUsed, timeLastUsed);
+  Assert.equal(address.timesUsed, timesUsed + 1);
+  Assert.notEqual(address.timeLastUsed, timeLastUsed);
 
   // Using a record should not bump its change counter.
-  do_check_eq(getSyncChangeCounter(profileStorage.addresses, guid),
+  Assert.equal(getSyncChangeCounter(profileStorage.addresses, guid),
     changeCounter);
 
   Assert.throws(() => profileStorage.addresses.notifyUsed("INVALID_GUID"),
     /No matching record\./);
 });
 
 add_task(async function test_remove() {
   let profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME,
                                                 [TEST_ADDRESS_1, TEST_ADDRESS_2]);
 
   let addresses = profileStorage.addresses.getAll();
   let guid = addresses[1].guid;
 
   let onChanged = TestUtils.topicObserved("formautofill-storage-changed",
                                           (subject, data) => data == "remove");
 
-  do_check_eq(addresses.length, 2);
+  Assert.equal(addresses.length, 2);
 
   profileStorage.addresses.remove(guid);
   await onChanged;
 
   addresses = profileStorage.addresses.getAll();
 
-  do_check_eq(addresses.length, 1);
+  Assert.equal(addresses.length, 1);
 
-  do_check_eq(profileStorage.addresses.get(guid), null);
+  Assert.equal(profileStorage.addresses.get(guid), null);
 });
 
 MERGE_TESTCASES.forEach((testcase) => {
   add_task(async function test_merge() {
-    do_print("Starting testcase: " + testcase.description);
+    info("Starting testcase: " + testcase.description);
     let profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME,
                                                   [testcase.addressInStorage]);
     let addresses = profileStorage.addresses.getAll();
     let guid = addresses[0].guid;
     let timeLastModified = addresses[0].timeLastModified;
 
     // Merge address and verify the guid in notifyObservers subject
     let onMerged = TestUtils.topicObserved(
       "formautofill-storage-changed",
       (subject, data) =>
         data == "update" && subject.QueryInterface(Ci.nsISupportsString).data == guid
     );
 
     // Force to create sync metadata.
     profileStorage.addresses.pullSyncChanges();
-    do_check_eq(getSyncChangeCounter(profileStorage.addresses, guid), 1);
+    Assert.equal(getSyncChangeCounter(profileStorage.addresses, guid), 1);
 
     Assert.ok(profileStorage.addresses.mergeIfPossible(guid,
                                                        testcase.addressToMerge,
                                                        testcase.strict));
     if (!testcase.noNeedToUpdate) {
       await onMerged;
     }
 
     addresses = profileStorage.addresses.getAll();
     Assert.equal(addresses.length, 1);
     do_check_record_matches(addresses[0], testcase.expectedAddress);
     if (testcase.noNeedToUpdate) {
       Assert.equal(addresses[0].timeLastModified, timeLastModified);
 
       // No need to bump the change counter if the data is unchanged.
-      do_check_eq(getSyncChangeCounter(profileStorage.addresses, guid), 1);
+      Assert.equal(getSyncChangeCounter(profileStorage.addresses, guid), 1);
     } else {
       Assert.notEqual(addresses[0].timeLastModified, timeLastModified);
 
       // Record merging should bump the change counter.
-      do_check_eq(getSyncChangeCounter(profileStorage.addresses, guid), 2);
+      Assert.equal(getSyncChangeCounter(profileStorage.addresses, guid), 2);
     }
   });
 });
 
 add_task(async function test_merge_same_address() {
   let profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME, [TEST_ADDRESS_1]);
   let addresses = profileStorage.addresses.getAll();
   let guid = addresses[0].guid;
   let timeLastModified = addresses[0].timeLastModified;
 
   // Force to create sync metadata.
   profileStorage.addresses.pullSyncChanges();
-  do_check_eq(getSyncChangeCounter(profileStorage.addresses, guid), 1);
+  Assert.equal(getSyncChangeCounter(profileStorage.addresses, guid), 1);
 
   // Merge same address will still return true but it won't update timeLastModified.
   Assert.ok(profileStorage.addresses.mergeIfPossible(guid, TEST_ADDRESS_1));
   Assert.equal(addresses[0].timeLastModified, timeLastModified);
 
   // ... and won't bump the change counter, either.
-  do_check_eq(getSyncChangeCounter(profileStorage.addresses, guid), 1);
+  Assert.equal(getSyncChangeCounter(profileStorage.addresses, guid), 1);
 });
 
 add_task(async function test_merge_unable_merge() {
   let profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME,
                                                 [TEST_ADDRESS_1, TEST_ADDRESS_2]);
 
   let addresses = profileStorage.addresses.getAll();
   let guid = addresses[1].guid;
 
   // Force to create sync metadata.
   profileStorage.addresses.pullSyncChanges();
-  do_check_eq(getSyncChangeCounter(profileStorage.addresses, guid), 1);
+  Assert.equal(getSyncChangeCounter(profileStorage.addresses, guid), 1);
 
   // Unable to merge because of conflict
-  do_check_eq(profileStorage.addresses.mergeIfPossible(guid, TEST_ADDRESS_3), false);
+  Assert.equal(profileStorage.addresses.mergeIfPossible(guid, TEST_ADDRESS_3), false);
 
   // Unable to merge because no overlap
-  do_check_eq(profileStorage.addresses.mergeIfPossible(guid, TEST_ADDRESS_4), false);
+  Assert.equal(profileStorage.addresses.mergeIfPossible(guid, TEST_ADDRESS_4), false);
 
   // Unable to strict merge because subset with empty string
   let subset = Object.assign({}, TEST_ADDRESS_1);
   subset.organization = "";
-  do_check_eq(profileStorage.addresses.mergeIfPossible(guid, subset, true), false);
+  Assert.equal(profileStorage.addresses.mergeIfPossible(guid, subset, true), false);
 
   // Shouldn't bump the change counter
-  do_check_eq(getSyncChangeCounter(profileStorage.addresses, guid), 1);
+  Assert.equal(getSyncChangeCounter(profileStorage.addresses, guid), 1);
 });
 
 add_task(async function test_mergeToStorage() {
   let profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME,
                                                 [TEST_ADDRESS_1, TEST_ADDRESS_2]);
   // Merge an address to storage
   let anotherAddress = profileStorage.addresses._clone(TEST_ADDRESS_2);
   profileStorage.addresses.add(anotherAddress);
   anotherAddress.email = "timbl@w3.org";
-  do_check_eq(profileStorage.addresses.mergeToStorage(anotherAddress).length, 2);
-  do_check_eq(profileStorage.addresses.getAll()[1].email, anotherAddress.email);
-  do_check_eq(profileStorage.addresses.getAll()[2].email, anotherAddress.email);
+  Assert.equal(profileStorage.addresses.mergeToStorage(anotherAddress).length, 2);
+  Assert.equal(profileStorage.addresses.getAll()[1].email, anotherAddress.email);
+  Assert.equal(profileStorage.addresses.getAll()[2].email, anotherAddress.email);
 
   // Empty computed fields shouldn't cause any problem.
-  do_check_eq(profileStorage.addresses.mergeToStorage(TEST_ADDRESS_WITH_EMPTY_COMPUTED_FIELD).length, 3);
+  Assert.equal(profileStorage.addresses.mergeToStorage(TEST_ADDRESS_WITH_EMPTY_COMPUTED_FIELD).length, 3);
 });
 
 add_task(async function test_mergeToStorage_strict() {
   let profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME,
                                                 [TEST_ADDRESS_1, TEST_ADDRESS_2]);
   // Try to merge a subset with empty string
   let anotherAddress = profileStorage.addresses._clone(TEST_ADDRESS_1);
   anotherAddress.email = "";
-  do_check_eq(profileStorage.addresses.mergeToStorage(anotherAddress, true).length, 0);
-  do_check_eq(profileStorage.addresses.getAll()[0].email, TEST_ADDRESS_1.email);
+  Assert.equal(profileStorage.addresses.mergeToStorage(anotherAddress, true).length, 0);
+  Assert.equal(profileStorage.addresses.getAll()[0].email, TEST_ADDRESS_1.email);
 
   // Empty computed fields shouldn't cause any problem.
-  do_check_eq(profileStorage.addresses.mergeToStorage(TEST_ADDRESS_WITH_EMPTY_COMPUTED_FIELD, true).length, 1);
+  Assert.equal(profileStorage.addresses.mergeToStorage(TEST_ADDRESS_WITH_EMPTY_COMPUTED_FIELD, true).length, 1);
 });
--- a/browser/extensions/formautofill/test/unit/test_autofillFormFields.js
+++ b/browser/extensions/formautofill/test/unit/test_autofillFormFields.js
@@ -485,17 +485,17 @@ const TESTCASES_FILL_SELECT = [
   },
 ];
 
 function do_test(testcases, testFn) {
   for (let tc of testcases) {
     (function() {
       let testcase = tc;
       add_task(async function() {
-        do_print("Starting testcase: " + testcase.description);
+        info("Starting testcase: " + testcase.description);
         let ccNumber = testcase.profileData["cc-number"];
         if (ccNumber) {
           testcase.profileData["cc-number-encrypted"] = await MasterPassword.encrypt(ccNumber);
           delete testcase.profileData["cc-number"];
         }
 
         let doc = MockDocument.createTestDocument("http://localhost:8080/test/",
                                                   testcase.document);
@@ -507,17 +507,17 @@ function do_test(testcases, testFn) {
         let decryptHelper = async (cipherText, reauth) => {
           let string;
           try {
             string = await MasterPassword.decrypt(cipherText, reauth);
           } catch (e) {
             if (e.result != Cr.NS_ERROR_ABORT) {
               throw e;
             }
-            do_print("User canceled master password entry");
+            info("User canceled master password entry");
           }
           return string;
         };
 
         handler.collectFormFields();
         for (let section of handler.sections) {
           section._decrypt = decryptHelper;
         }
--- a/browser/extensions/formautofill/test/unit/test_collectFormFields.js
+++ b/browser/extensions/formautofill/test/unit/test_collectFormFields.js
@@ -431,17 +431,17 @@ const TESTCASES = [
     ids: ["given-name", "family-name", "dummyAreaCode"],
   },
 ];
 
 for (let tc of TESTCASES) {
   (function() {
     let testcase = tc;
     add_task(async function() {
-      do_print("Starting testcase: " + testcase.description);
+      info("Starting testcase: " + testcase.description);
 
       let doc = MockDocument.createTestDocument("http://localhost:8080/test/",
                                                 testcase.document);
       let form = doc.querySelector("form");
       let formLike = FormLikeFactory.createFromForm(form);
 
       function setElementWeakRef(details) {
         if (!details) {
--- a/browser/extensions/formautofill/test/unit/test_createRecords.js
+++ b/browser/extensions/formautofill/test/unit/test_createRecords.js
@@ -364,17 +364,17 @@ const TESTCASES = [
       }],
     },
   },
 
 ];
 
 for (let testcase of TESTCASES) {
   add_task(async function() {
-    do_print("Starting testcase: " + testcase.description);
+    info("Starting testcase: " + testcase.description);
 
     let doc = MockDocument.createTestDocument("http://localhost:8080/test/", testcase.document);
     let form = doc.querySelector("form");
     let formLike = FormLikeFactory.createFromForm(form);
     let handler = new FormAutofillHandler(formLike);
 
     handler.collectFormFields();
 
--- a/browser/extensions/formautofill/test/unit/test_creditCardRecords.js
+++ b/browser/extensions/formautofill/test/unit/test_creditCardRecords.js
@@ -145,46 +145,46 @@ const MERGE_TESTCASES = [
 ];
 
 let prepareTestCreditCards = async function(path) {
   let profileStorage = new ProfileStorage(path);
   await profileStorage.initialize();
 
   let onChanged = TestUtils.topicObserved("formautofill-storage-changed",
                                           (subject, data) => data == "add");
-  do_check_true(profileStorage.creditCards.add(TEST_CREDIT_CARD_1));
+  Assert.ok(profileStorage.creditCards.add(TEST_CREDIT_CARD_1));
   await onChanged;
-  do_check_true(profileStorage.creditCards.add(TEST_CREDIT_CARD_2));
+  Assert.ok(profileStorage.creditCards.add(TEST_CREDIT_CARD_2));
   await onChanged;
   await profileStorage._saveImmediately();
 };
 
 let reCCNumber = /^(\*+)(.{4})$/;
 
 let do_check_credit_card_matches = (creditCardWithMeta, creditCard) => {
   for (let key in creditCard) {
     if (key == "cc-number") {
       let matches = reCCNumber.exec(creditCardWithMeta["cc-number"]);
-      do_check_neq(matches, null);
-      do_check_eq(creditCardWithMeta["cc-number"].length, creditCard["cc-number"].length);
-      do_check_eq(creditCard["cc-number"].endsWith(matches[2]), true);
-      do_check_neq(creditCard["cc-number-encrypted"], "");
+      Assert.notEqual(matches, null);
+      Assert.equal(creditCardWithMeta["cc-number"].length, creditCard["cc-number"].length);
+      Assert.equal(creditCard["cc-number"].endsWith(matches[2]), true);
+      Assert.notEqual(creditCard["cc-number-encrypted"], "");
     } else {
-      do_check_eq(creditCardWithMeta[key], creditCard[key]);
+      Assert.equal(creditCardWithMeta[key], creditCard[key]);
     }
   }
 };
 
 add_task(async function test_initialize() {
   let path = getTempFile(TEST_STORE_FILE_NAME).path;
   let profileStorage = new ProfileStorage(path);
   await profileStorage.initialize();
 
-  do_check_eq(profileStorage._store.data.version, 1);
-  do_check_eq(profileStorage._store.data.creditCards.length, 0);
+  Assert.equal(profileStorage._store.data.version, 1);
+  Assert.equal(profileStorage._store.data.creditCards.length, 0);
 
   let data = profileStorage._store.data;
   Assert.deepEqual(data.creditCards, []);
 
   await profileStorage._saveImmediately();
 
   profileStorage = new ProfileStorage(path);
   await profileStorage.initialize();
@@ -196,30 +196,30 @@ add_task(async function test_getAll() {
   let path = getTempFile(TEST_STORE_FILE_NAME).path;
   await prepareTestCreditCards(path);
 
   let profileStorage = new ProfileStorage(path);
   await profileStorage.initialize();
 
   let creditCards = profileStorage.creditCards.getAll();
 
-  do_check_eq(creditCards.length, 2);
+  Assert.equal(creditCards.length, 2);
   do_check_credit_card_matches(creditCards[0], TEST_CREDIT_CARD_1);
   do_check_credit_card_matches(creditCards[1], TEST_CREDIT_CARD_2);
 
   // Check computed fields.
-  do_check_eq(creditCards[0]["cc-given-name"], "John");
-  do_check_eq(creditCards[0]["cc-family-name"], "Doe");
-  do_check_eq(creditCards[0]["cc-exp"], "2017-04");
+  Assert.equal(creditCards[0]["cc-given-name"], "John");
+  Assert.equal(creditCards[0]["cc-family-name"], "Doe");
+  Assert.equal(creditCards[0]["cc-exp"], "2017-04");
 
   // Test with rawData set.
   creditCards = profileStorage.creditCards.getAll({rawData: true});
-  do_check_eq(creditCards[0]["cc-given-name"], undefined);
-  do_check_eq(creditCards[0]["cc-family-name"], undefined);
-  do_check_eq(creditCards[0]["cc-exp"], undefined);
+  Assert.equal(creditCards[0]["cc-given-name"], undefined);
+  Assert.equal(creditCards[0]["cc-family-name"], undefined);
+  Assert.equal(creditCards[0]["cc-exp"], undefined);
 
   // Modifying output shouldn't affect the storage.
   creditCards[0]["cc-name"] = "test";
   do_check_credit_card_matches(profileStorage.creditCards.getAll()[0], TEST_CREDIT_CARD_1);
 });
 
 add_task(async function test_get() {
   let path = getTempFile(TEST_STORE_FILE_NAME).path;
@@ -233,50 +233,50 @@ add_task(async function test_get() {
 
   let creditCard = profileStorage.creditCards.get(guid);
   do_check_credit_card_matches(creditCard, TEST_CREDIT_CARD_1);
 
   // Modifying output shouldn't affect the storage.
   creditCards[0]["cc-name"] = "test";
   do_check_credit_card_matches(profileStorage.creditCards.get(guid), TEST_CREDIT_CARD_1);
 
-  do_check_eq(profileStorage.creditCards.get("INVALID_GUID"), null);
+  Assert.equal(profileStorage.creditCards.get("INVALID_GUID"), null);
 });
 
 add_task(async function test_add() {
   let path = getTempFile(TEST_STORE_FILE_NAME).path;
   await prepareTestCreditCards(path);
 
   let profileStorage = new ProfileStorage(path);
   await profileStorage.initialize();
 
   let creditCards = profileStorage.creditCards.getAll();
 
-  do_check_eq(creditCards.length, 2);
+  Assert.equal(creditCards.length, 2);
 
   do_check_credit_card_matches(creditCards[0], TEST_CREDIT_CARD_1);
   do_check_credit_card_matches(creditCards[1], TEST_CREDIT_CARD_2);
 
-  do_check_neq(creditCards[0].guid, undefined);
-  do_check_eq(creditCards[0].version, 1);
-  do_check_neq(creditCards[0].timeCreated, undefined);
-  do_check_eq(creditCards[0].timeLastModified, creditCards[0].timeCreated);
-  do_check_eq(creditCards[0].timeLastUsed, 0);
-  do_check_eq(creditCards[0].timesUsed, 0);
+  Assert.notEqual(creditCards[0].guid, undefined);
+  Assert.equal(creditCards[0].version, 1);
+  Assert.notEqual(creditCards[0].timeCreated, undefined);
+  Assert.equal(creditCards[0].timeLastModified, creditCards[0].timeCreated);
+  Assert.equal(creditCards[0].timeLastUsed, 0);
+  Assert.equal(creditCards[0].timesUsed, 0);
 
   // Empty string should be deleted before saving.
   profileStorage.creditCards.add(TEST_CREDIT_CARD_WITH_EMPTY_FIELD);
   let creditCard = profileStorage.creditCards._data[2];
-  do_check_eq(creditCard["cc-exp-month"], TEST_CREDIT_CARD_WITH_EMPTY_FIELD["cc-exp-month"]);
-  do_check_eq(creditCard["cc-name"], undefined);
+  Assert.equal(creditCard["cc-exp-month"], TEST_CREDIT_CARD_WITH_EMPTY_FIELD["cc-exp-month"]);
+  Assert.equal(creditCard["cc-name"], undefined);
 
   // Empty computed fields shouldn't cause any problem.
   profileStorage.creditCards.add(TEST_CREDIT_CARD_WITH_EMPTY_COMPUTED_FIELD);
   creditCard = profileStorage.creditCards._data[3];
-  do_check_eq(creditCard["cc-number"],
+  Assert.equal(creditCard["cc-number"],
     profileStorage.creditCards._getMaskedCCNumber(TEST_CREDIT_CARD_WITH_EMPTY_COMPUTED_FIELD["cc-number"]));
 
   Assert.throws(() => profileStorage.creditCards.add(TEST_CREDIT_CARD_WITH_INVALID_FIELD),
     /"invalidField" is not a valid field\./);
 
   Assert.throws(() => profileStorage.creditCards.add({}),
     /Record contains no valid field\./);
 
@@ -293,44 +293,44 @@ add_task(async function test_update() {
 
   let creditCards = profileStorage.creditCards.getAll();
   let guid = creditCards[1].guid;
   let timeLastModified = creditCards[1].timeLastModified;
 
   let onChanged = TestUtils.topicObserved("formautofill-storage-changed",
                                           (subject, data) => data == "update");
 
-  do_check_neq(creditCards[1]["cc-name"], undefined);
+  Assert.notEqual(creditCards[1]["cc-name"], undefined);
   profileStorage.creditCards.update(guid, TEST_CREDIT_CARD_3);
   await onChanged;
   await profileStorage._saveImmediately();
 
   profileStorage = new ProfileStorage(path);
   await profileStorage.initialize();
 
   let creditCard = profileStorage.creditCards.get(guid);
 
-  do_check_eq(creditCard["cc-name"], undefined);
-  do_check_neq(creditCard.timeLastModified, timeLastModified);
+  Assert.equal(creditCard["cc-name"], undefined);
+  Assert.notEqual(creditCard.timeLastModified, timeLastModified);
   do_check_credit_card_matches(creditCard, TEST_CREDIT_CARD_3);
 
   // Empty string should be deleted while updating.
   profileStorage.creditCards.update(profileStorage.creditCards._data[0].guid, TEST_CREDIT_CARD_WITH_EMPTY_FIELD);
   creditCard = profileStorage.creditCards._data[0];
-  do_check_eq(creditCard["cc-exp-month"], TEST_CREDIT_CARD_WITH_EMPTY_FIELD["cc-exp-month"]);
-  do_check_eq(creditCard["cc-name"], undefined);
+  Assert.equal(creditCard["cc-exp-month"], TEST_CREDIT_CARD_WITH_EMPTY_FIELD["cc-exp-month"]);
+  Assert.equal(creditCard["cc-name"], undefined);
 
   // Empty computed fields shouldn't cause any problem.
   profileStorage.creditCards.update(profileStorage.creditCards._data[0].guid, TEST_CREDIT_CARD_WITH_EMPTY_COMPUTED_FIELD, false);
   creditCard = profileStorage.creditCards._data[0];
-  do_check_eq(creditCard["cc-number"],
+  Assert.equal(creditCard["cc-number"],
     profileStorage.creditCards._getMaskedCCNumber(TEST_CREDIT_CARD_WITH_EMPTY_COMPUTED_FIELD["cc-number"]));
   profileStorage.creditCards.update(profileStorage.creditCards._data[1].guid, TEST_CREDIT_CARD_WITH_EMPTY_COMPUTED_FIELD, true);
   creditCard = profileStorage.creditCards._data[1];
-  do_check_eq(creditCard["cc-number"],
+  Assert.equal(creditCard["cc-number"],
     profileStorage.creditCards._getMaskedCCNumber(TEST_CREDIT_CARD_WITH_EMPTY_COMPUTED_FIELD["cc-number"]));
 
   Assert.throws(
     () => profileStorage.creditCards.update("INVALID_GUID", TEST_CREDIT_CARD_3),
     /No matching record\./
   );
 
   Assert.throws(
@@ -362,27 +362,27 @@ add_task(async function test_validate() 
   await profileStorage.initialize();
 
   profileStorage.creditCards.add(TEST_CREDIT_CARD_WITH_INVALID_EXPIRY_DATE);
   profileStorage.creditCards.add(TEST_CREDIT_CARD_WITH_2_DIGITS_YEAR);
   profileStorage.creditCards.add(TEST_CREDIT_CARD_WITH_SPACES_BETWEEN_DIGITS);
 
   let creditCards = profileStorage.creditCards.getAll();
 
-  do_check_eq(creditCards[0]["cc-exp-month"], undefined);
-  do_check_eq(creditCards[0]["cc-exp-year"], undefined);
-  do_check_eq(creditCards[0]["cc-exp"], undefined);
+  Assert.equal(creditCards[0]["cc-exp-month"], undefined);
+  Assert.equal(creditCards[0]["cc-exp-year"], undefined);
+  Assert.equal(creditCards[0]["cc-exp"], undefined);
 
   let month = TEST_CREDIT_CARD_WITH_2_DIGITS_YEAR["cc-exp-month"];
   let year = parseInt(TEST_CREDIT_CARD_WITH_2_DIGITS_YEAR["cc-exp-year"], 10) + 2000;
-  do_check_eq(creditCards[1]["cc-exp-month"], month);
-  do_check_eq(creditCards[1]["cc-exp-year"], year);
-  do_check_eq(creditCards[1]["cc-exp"], year + "-" + month.toString().padStart(2, "0"));
+  Assert.equal(creditCards[1]["cc-exp-month"], month);
+  Assert.equal(creditCards[1]["cc-exp-year"], year);
+  Assert.equal(creditCards[1]["cc-exp"], year + "-" + month.toString().padStart(2, "0"));
 
-  do_check_eq(creditCards[2]["cc-number"].length, 16);
+  Assert.equal(creditCards[2]["cc-number"].length, 16);
 });
 
 add_task(async function test_notifyUsed() {
   let path = getTempFile(TEST_STORE_FILE_NAME).path;
   await prepareTestCreditCards(path);
 
   let profileStorage = new ProfileStorage(path);
   await profileStorage.initialize();
@@ -399,18 +399,18 @@ add_task(async function test_notifyUsed(
   await onChanged;
   await profileStorage._saveImmediately();
 
   profileStorage = new ProfileStorage(path);
   await profileStorage.initialize();
 
   let creditCard = profileStorage.creditCards.get(guid);
 
-  do_check_eq(creditCard.timesUsed, timesUsed + 1);
-  do_check_neq(creditCard.timeLastUsed, timeLastUsed);
+  Assert.equal(creditCard.timesUsed, timesUsed + 1);
+  Assert.notEqual(creditCard.timeLastUsed, timeLastUsed);
 
   Assert.throws(() => profileStorage.creditCards.notifyUsed("INVALID_GUID"),
     /No matching record\./);
 });
 
 add_task(async function test_remove() {
   let path = getTempFile(TEST_STORE_FILE_NAME).path;
   await prepareTestCreditCards(path);
@@ -419,146 +419,146 @@ add_task(async function test_remove() {
   await profileStorage.initialize();
 
   let creditCards = profileStorage.creditCards.getAll();
   let guid = creditCards[1].guid;
 
   let onChanged = TestUtils.topicObserved("formautofill-storage-changed",
                                           (subject, data) => data == "remove");
 
-  do_check_eq(creditCards.length, 2);
+  Assert.equal(creditCards.length, 2);
 
   profileStorage.creditCards.remove(guid);
   await onChanged;
   await profileStorage._saveImmediately();
 
   profileStorage = new ProfileStorage(path);
   await profileStorage.initialize();
 
   creditCards = profileStorage.creditCards.getAll();
 
-  do_check_eq(creditCards.length, 1);
+  Assert.equal(creditCards.length, 1);
 
-  do_check_eq(profileStorage.creditCards.get(guid), null);
+  Assert.equal(profileStorage.creditCards.get(guid), null);
 });
 
 MERGE_TESTCASES.forEach((testcase) => {
   add_task(async function test_merge() {
-    do_print("Starting testcase: " + testcase.description);
+    info("Starting testcase: " + testcase.description);
     let profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME,
                                                   [testcase.creditCardInStorage],
                                                   "creditCards");
     let creditCards = profileStorage.creditCards.getAll();
     let guid = creditCards[0].guid;
     let timeLastModified = creditCards[0].timeLastModified;
     // Merge creditCard and verify the guid in notifyObservers subject
     let onMerged = TestUtils.topicObserved(
       "formautofill-storage-changed",
       (subject, data) =>
         data == "update" && subject.QueryInterface(Ci.nsISupportsString).data == guid
     );
     // Force to create sync metadata.
     profileStorage.creditCards.pullSyncChanges();
-    do_check_eq(getSyncChangeCounter(profileStorage.creditCards, guid), 1);
+    Assert.equal(getSyncChangeCounter(profileStorage.creditCards, guid), 1);
     Assert.ok(profileStorage.creditCards.mergeIfPossible(guid, testcase.creditCardToMerge));
     if (!testcase.noNeedToUpdate) {
       await onMerged;
     }
     creditCards = profileStorage.creditCards.getAll();
     Assert.equal(creditCards.length, 1);
     do_check_credit_card_matches(creditCards[0], testcase.expectedCreditCard);
     if (!testcase.noNeedToUpdate) {
       // Record merging should update timeLastModified and bump the change counter.
       Assert.notEqual(creditCards[0].timeLastModified, timeLastModified);
-      do_check_eq(getSyncChangeCounter(profileStorage.creditCards, guid), 2);
+      Assert.equal(getSyncChangeCounter(profileStorage.creditCards, guid), 2);
     } else {
       // Subset record merging should not update timeLastModified and the change
       // counter is still the same.
       Assert.equal(creditCards[0].timeLastModified, timeLastModified);
-      do_check_eq(getSyncChangeCounter(profileStorage.creditCards, guid), 1);
+      Assert.equal(getSyncChangeCounter(profileStorage.creditCards, guid), 1);
     }
   });
 });
 
 add_task(async function test_merge_unable_merge() {
   let profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME,
                                                 [TEST_CREDIT_CARD_1],
                                                 "creditCards");
 
   let creditCards = profileStorage.creditCards.getAll();
   let guid = creditCards[0].guid;
   // Force to create sync metadata.
   profileStorage.creditCards.pullSyncChanges();
-  do_check_eq(getSyncChangeCounter(profileStorage.creditCards, guid), 1);
+  Assert.equal(getSyncChangeCounter(profileStorage.creditCards, guid), 1);
 
   // Unable to merge because of conflict
   let anotherCreditCard = profileStorage.creditCards._clone(TEST_CREDIT_CARD_1);
   anotherCreditCard["cc-name"] = "Foo Bar";
-  do_check_eq(profileStorage.creditCards.mergeIfPossible(guid, anotherCreditCard), false);
+  Assert.equal(profileStorage.creditCards.mergeIfPossible(guid, anotherCreditCard), false);
   // The change counter is unchanged.
-  do_check_eq(getSyncChangeCounter(profileStorage.creditCards, guid), 1);
+  Assert.equal(getSyncChangeCounter(profileStorage.creditCards, guid), 1);
 
   // Unable to merge because no credit card number
   anotherCreditCard = profileStorage.creditCards._clone(TEST_CREDIT_CARD_1);
   anotherCreditCard["cc-number"] = "";
-  do_check_eq(profileStorage.creditCards.mergeIfPossible(guid, anotherCreditCard), false);
+  Assert.equal(profileStorage.creditCards.mergeIfPossible(guid, anotherCreditCard), false);
   // The change counter is still unchanged.
-  do_check_eq(getSyncChangeCounter(profileStorage.creditCards, guid), 1);
+  Assert.equal(getSyncChangeCounter(profileStorage.creditCards, guid), 1);
 });
 
 add_task(async function test_mergeToStorage() {
   let profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME,
                                                 [TEST_CREDIT_CARD_3, TEST_CREDIT_CARD_4],
                                                 "creditCards");
   // Merge a creditCard to storage
   let anotherCreditCard = profileStorage.creditCards._clone(TEST_CREDIT_CARD_3);
   anotherCreditCard["cc-name"] = "Foo Bar";
-  do_check_eq(profileStorage.creditCards.mergeToStorage(anotherCreditCard).length, 2);
-  do_check_eq(profileStorage.creditCards.getAll()[0]["cc-name"], "Foo Bar");
-  do_check_eq(profileStorage.creditCards.getAll()[0]["cc-exp"], "2000-01");
-  do_check_eq(profileStorage.creditCards.getAll()[1]["cc-name"], "Foo Bar");
-  do_check_eq(profileStorage.creditCards.getAll()[1]["cc-exp"], "2000-01");
+  Assert.equal(profileStorage.creditCards.mergeToStorage(anotherCreditCard).length, 2);
+  Assert.equal(profileStorage.creditCards.getAll()[0]["cc-name"], "Foo Bar");
+  Assert.equal(profileStorage.creditCards.getAll()[0]["cc-exp"], "2000-01");
+  Assert.equal(profileStorage.creditCards.getAll()[1]["cc-name"], "Foo Bar");
+  Assert.equal(profileStorage.creditCards.getAll()[1]["cc-exp"], "2000-01");
 
   // Empty computed fields shouldn't cause any problem.
-  do_check_eq(profileStorage.creditCards.mergeToStorage(TEST_CREDIT_CARD_WITH_EMPTY_COMPUTED_FIELD).length, 0);
+  Assert.equal(profileStorage.creditCards.mergeToStorage(TEST_CREDIT_CARD_WITH_EMPTY_COMPUTED_FIELD).length, 0);
 });
 
 add_task(async function test_getDuplicateGuid() {
   let profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME,
                                                 [TEST_CREDIT_CARD_3],
                                                 "creditCards");
   let guid = profileStorage.creditCards._data[0].guid;
 
   // Absolutely a duplicate.
-  do_check_eq(profileStorage.creditCards.getDuplicateGuid(TEST_CREDIT_CARD_3), guid);
+  Assert.equal(profileStorage.creditCards.getDuplicateGuid(TEST_CREDIT_CARD_3), guid);
 
   // Absolutely not a duplicate.
-  do_check_eq(profileStorage.creditCards.getDuplicateGuid(TEST_CREDIT_CARD_1), null);
+  Assert.equal(profileStorage.creditCards.getDuplicateGuid(TEST_CREDIT_CARD_1), null);
 
   // Subset shouldn't be treated as a duplicate.
   let record = Object.assign({}, TEST_CREDIT_CARD_3);
   delete record["cc-exp-month"];
-  do_check_eq(profileStorage.creditCards.getDuplicateGuid(record), null);
+  Assert.equal(profileStorage.creditCards.getDuplicateGuid(record), null);
 
   // Superset shouldn't be treated as a duplicate.
   record = Object.assign({}, TEST_CREDIT_CARD_3);
   record["cc-name"] = "John Doe";
-  do_check_eq(profileStorage.creditCards.getDuplicateGuid(record), null);
+  Assert.equal(profileStorage.creditCards.getDuplicateGuid(record), null);
 
   // Numbers with the same last 4 digits shouldn't be treated as a duplicate.
   record = Object.assign({}, TEST_CREDIT_CARD_3);
   let last4Digits = record["cc-number"].substr(-4);
   record["cc-number"] = "000000000000" + last4Digits;
-  do_check_eq(profileStorage.creditCards.getDuplicateGuid(record), null);
+  Assert.equal(profileStorage.creditCards.getDuplicateGuid(record), null);
 
   // ... However, we treat numbers with the same last 4 digits as a duplicate if
   // the master password is enabled.
   let tokendb = Cc["@mozilla.org/security/pk11tokendb;1"].createInstance(Ci.nsIPK11TokenDB);
   let token = tokendb.getInternalKeyToken();
   token.reset();
   token.initPassword("password");
-  do_check_eq(profileStorage.creditCards.getDuplicateGuid(record), guid);
+  Assert.equal(profileStorage.creditCards.getDuplicateGuid(record), guid);
 
   // ... Even though the master password is enabled and the last 4 digits are the
   // same, an invalid credit card number should never be treated as a duplicate.
   record["cc-number"] = "************" + last4Digits;
-  do_check_eq(profileStorage.creditCards.getDuplicateGuid(record), null);
+  Assert.equal(profileStorage.creditCards.getDuplicateGuid(record), null);
 });
--- a/browser/extensions/formautofill/test/unit/test_extractLabelStrings.js
+++ b/browser/extensions/formautofill/test/unit/test_extractLabelStrings.js
@@ -48,17 +48,17 @@ const TESTCASES = [
     inputId: "typeC",
     expectedStrings: ["label type C", "inner div prefix", "test C-1",
       "test C-2", "inner div postfix"],
   },
 ];
 
 TESTCASES.forEach(testcase => {
   add_task(async function() {
-    do_print("Starting testcase: " + testcase.description);
+    info("Starting testcase: " + testcase.description);
     LabelUtils._labelStrings = new WeakMap();
 
     let doc = MockDocument.createTestDocument(
       "http://localhost:8080/test/", testcase.document);
 
     let element = doc.getElementById(testcase.inputId);
     let strings = LabelUtils.extractLabelStrings(element);
 
--- a/browser/extensions/formautofill/test/unit/test_findLabelElements.js
+++ b/browser/extensions/formautofill/test/unit/test_findLabelElements.js
@@ -72,17 +72,17 @@ const TESTCASES = [
                <label id="labelG3" for="typeG">label type G3</label>`,
     inputId: "typeG",
     expectedLabelIds: ["labelG1", "labelG2", "labelG3"],
   },
 ];
 
 TESTCASES.forEach(testcase => {
   add_task(async function() {
-    do_print("Starting testcase: " + testcase.description);
+    info("Starting testcase: " + testcase.description);
 
     let doc = MockDocument.createTestDocument(
       "http://localhost:8080/test/", testcase.document);
 
     let input = doc.getElementById(testcase.inputId);
     let labels = LabelUtils.findLabelElements(input);
 
     Assert.deepEqual(labels.map(l => l.id), testcase.expectedLabelIds);
--- a/browser/extensions/formautofill/test/unit/test_getAdaptedProfiles.js
+++ b/browser/extensions/formautofill/test/unit/test_getAdaptedProfiles.js
@@ -920,17 +920,17 @@ const TESTCASES = [
                <input placeholder="mm - - yyyy" autocomplete="cc-exp"></form>`,
     profileData: [Object.assign({}, DEFAULT_CREDITCARD_RECORD)],
     expectedResult: [Object.assign({}, DEFAULT_CREDITCARD_RECORD)],
   },
 ];
 
 for (let testcase of TESTCASES) {
   add_task(async function() {
-    do_print("Starting testcase: " + testcase.description);
+    info("Starting testcase: " + testcase.description);
 
     let doc = MockDocument.createTestDocument("http://localhost:8080/test/",
                                               testcase.document);
     let form = doc.querySelector("form");
     let formLike = FormLikeFactory.createFromForm(form);
     let handler = new FormAutofillHandler(formLike);
 
     handler.collectFormFields();
--- a/browser/extensions/formautofill/test/unit/test_getCategoriesFromFieldNames.js
+++ b/browser/extensions/formautofill/test/unit/test_getCategoriesFromFieldNames.js
@@ -35,23 +35,23 @@ add_task(async function test_isAddressFi
     },
     "": {
       isAddressField: false,
       isCreditCardField: false,
     },
   };
 
   for (let fieldName of Object.keys(TEST_CASES)) {
-    do_print("Starting testcase: " + fieldName);
-    let info = TEST_CASES[fieldName];
+    info("Starting testcase: " + fieldName);
+    let field = TEST_CASES[fieldName];
     Assert.equal(FormAutofillUtils.isAddressField(fieldName),
-                 info.isAddressField,
+                 field.isAddressField,
                  "isAddressField");
     Assert.equal(FormAutofillUtils.isCreditCardField(fieldName),
-                 info.isCreditCardField,
+                 field.isCreditCardField,
                  "isCreditCardField");
   }
 });
 
 add_task(async function test_getCategoriesFromFieldNames() {
   const TEST_CASES = [
     {
       fieldNames: ["given-name", "family-name", "name", "tel", "organization"],
--- a/browser/extensions/formautofill/test/unit/test_getFormInputDetails.js
+++ b/browser/extensions/formautofill/test/unit/test_getFormInputDetails.js
@@ -75,17 +75,17 @@ function inputDetailAssertion(detail, ex
   Assert.equal(detail.addressType, expected.addressType);
   Assert.equal(detail.contactType, expected.contactType);
   Assert.equal(detail.fieldName, expected.fieldName);
   Assert.equal(detail.elementWeakRef.get(), expected.elementWeakRef.get());
 }
 
 TESTCASES.forEach(testcase => {
   add_task(async function() {
-    do_print("Starting testcase: " + testcase.description);
+    info("Starting testcase: " + testcase.description);
 
     let doc = MockDocument.createTestDocument(
               "http://localhost:8080/test/", testcase.document);
 
     for (let i in testcase.targetInput) {
       let input = doc.getElementById(testcase.targetInput[i]);
       FormAutofillContent.identifyAutofillFields(input);
       FormAutofillContent.updateActiveInput(input);
--- a/browser/extensions/formautofill/test/unit/test_getInfo.js
+++ b/browser/extensions/formautofill/test/unit/test_getInfo.js
@@ -232,31 +232,31 @@ const TESTCASES = [
       addressType: "",
       contactType: "",
     },
   },
 ];
 
 TESTCASES.forEach(testcase => {
   add_task(async function() {
-    do_print("Starting testcase: " + testcase.description);
+    info("Starting testcase: " + testcase.description);
 
     let doc = MockDocument.createTestDocument(
       "http://localhost:8080/test/", testcase.document);
 
     let element = doc.getElementById(testcase.elementId);
     let value = FormAutofillHeuristics.getInfo(element);
 
     Assert.deepEqual(value, testcase.expectedReturnValue);
     LabelUtils.clearLabelMap();
   });
 });
 
 add_task(async function test_regexp_list() {
-  do_print("Verify the fieldName support for select element.");
+  info("Verify the fieldName support for select element.");
   let SUPPORT_LIST = {
     "email": null, // email
     "tel-extension": null, // tel-extension
     "phone": null, // tel
     "organization": null, // organization
     "street-address": null, // street-address
     "address1": null, // address-line1
     "address2": null, // address-line2
@@ -281,18 +281,18 @@ add_task(async function test_regexp_list
       elementId: label,
       expectedReturnValue: (SUPPORT_LIST[label] ? {
         fieldName: SUPPORT_LIST[label],
         section: "",
         addressType: "",
         contactType: "",
       } : null),
     };
-    do_print(testcase.description);
-    do_print(testcase.document);
+    info(testcase.description);
+    info(testcase.document);
     let doc = MockDocument.createTestDocument(
       "http://localhost:8080/test/", testcase.document);
 
     let element = doc.getElementById(testcase.elementId);
     let value = FormAutofillHeuristics.getInfo(element);
 
     Assert.deepEqual(value, testcase.expectedReturnValue, label);
   }
--- a/browser/extensions/formautofill/test/unit/test_getRecords.js
+++ b/browser/extensions/formautofill/test/unit/test_getRecords.js
@@ -73,17 +73,17 @@ add_task(async function test_getRecords(
 
     if (collection) {
       sinon.stub(collection, "getAll");
       collection.getAll.returns(expectedResult);
     }
     await formAutofillParent._getRecords({collectionName}, target);
     mock.verify();
     if (collection) {
-      do_check_eq(collection.getAll.called, true);
+      Assert.equal(collection.getAll.called, true);
       collection.getAll.restore();
     }
   }
 });
 
 add_task(async function test_getRecords_addresses() {
   let formAutofillParent = new FormAutofillParent();
 
@@ -147,17 +147,17 @@ add_task(async function test_getRecords_
         info: {fieldName: "tel"},
         searchString: "1",
       },
       expectedResult: [],
     },
   ];
 
   for (let testCase of testCases) {
-    do_print("Starting testcase: " + testCase.description);
+    info("Starting testcase: " + testCase.description);
     let mock = sinon.mock(target);
     mock.expects("sendAsyncMessage").once().withExactArgs("FormAutofill:Records",
                                                           testCase.expectedResult);
     await formAutofillParent._getRecords(testCase.filter, target);
     mock.verify();
   }
 });
 
@@ -243,17 +243,17 @@ add_task(async function test_getRecords_
         searchString: "123",
       },
       mpEnabled: true,
       expectedResult: encryptedCCRecords,
     },
   ];
 
   for (let testCase of testCases) {
-    do_print("Starting testcase: " + testCase.description);
+    info("Starting testcase: " + testCase.description);
     if (testCase.mpEnabled) {
       let tokendb = Cc["@mozilla.org/security/pk11tokendb;1"].createInstance(Ci.nsIPK11TokenDB);
       let token = tokendb.getInternalKeyToken();
       token.reset();
       token.initPassword("password");
     }
     let mock = sinon.mock(target);
     mock.expects("sendAsyncMessage").once().withExactArgs("FormAutofill:Records",
--- a/browser/extensions/formautofill/test/unit/test_isAvailable.js
+++ b/browser/extensions/formautofill/test/unit/test_isAvailable.js
@@ -2,31 +2,31 @@
  * Test enabling the feature in specific locales and regions.
  */
 
 "use strict";
 
 // Load bootstrap.js into a sandbox to be able to test `isAvailable`
 let sandbox = {};
 Services.scriptloader.loadSubScript(bootstrapURI, sandbox, "utf-8");
-do_print("bootstrapURI: " + bootstrapURI);
+info("bootstrapURI: " + bootstrapURI);
 
 add_task(async function test_defaultTestEnvironment() {
-  do_check_true(sandbox.isAvailable());
+  Assert.ok(sandbox.isAvailable());
 });
 
 add_task(async function test_unsupportedRegion() {
   Services.prefs.setCharPref("extensions.formautofill.available", "detect");
   Services.prefs.setCharPref("browser.search.region", "ZZ");
-  do_register_cleanup(function cleanupRegion() {
+  registerCleanupFunction(function cleanupRegion() {
     Services.prefs.clearUserPref("browser.search.region");
   });
-  do_check_false(sandbox.isAvailable());
+  Assert.ok(!sandbox.isAvailable());
 });
 
 add_task(async function test_supportedRegion() {
   Services.prefs.setCharPref("extensions.formautofill.available", "detect");
   Services.prefs.setCharPref("browser.search.region", "US");
-  do_register_cleanup(function cleanupRegion() {
+  registerCleanupFunction(function cleanupRegion() {
     Services.prefs.clearUserPref("browser.search.region");
   });
-  do_check_true(sandbox.isAvailable());
+  Assert.ok(sandbox.isAvailable());
 });
--- a/browser/extensions/formautofill/test/unit/test_isCJKName.js
+++ b/browser/extensions/formautofill/test/unit/test_isCJKName.js
@@ -63,13 +63,13 @@ const TESTCASES = [
     // CJK names don't have a middle name, so a 3-part name is bogus to us.
     fullName: "반 기 문",
     expectedResult: false,
   },
 ];
 
 add_task(async function test_isCJKName() {
   TESTCASES.forEach(testcase => {
-    do_print("Starting testcase: " + testcase.fullName);
+    info("Starting testcase: " + testcase.fullName);
     let result = FormAutofillNameUtils._isCJKName(testcase.fullName);
-    do_check_eq(result, testcase.expectedResult);
+    Assert.equal(result, testcase.expectedResult);
   });
 });
--- a/browser/extensions/formautofill/test/unit/test_isFieldEligibleForAutofill.js
+++ b/browser/extensions/formautofill/test/unit/test_isFieldEligibleForAutofill.js
@@ -62,17 +62,17 @@ const TESTCASES = [
     document: `<div id="targetElement"></div>`,
     fieldId: "targetElement",
     expectedResult: false,
   },
 ];
 
 TESTCASES.forEach(testcase => {
   add_task(async function() {
-    do_print("Starting testcase: " + testcase.document);
+    info("Starting testcase: " + testcase.document);
 
     let doc = MockDocument.createTestDocument(
       "http://localhost:8080/test/", testcase.document);
 
     let field = doc.getElementById(testcase.fieldId);
     Assert.equal(FormAutofillUtils.isFieldEligibleForAutofill(field),
                  testcase.expectedResult);
   });
--- a/browser/extensions/formautofill/test/unit/test_markAsAutofillField.js
+++ b/browser/extensions/formautofill/test/unit/test_markAsAutofillField.js
@@ -62,17 +62,17 @@ const TESTCASES = [
 
 let markedFieldId = [];
 FormAutofillContent._markAsAutofillField = function(field) {
   markedFieldId.push(field.id);
 };
 
 TESTCASES.forEach(testcase => {
   add_task(async function() {
-    do_print("Starting testcase: " + testcase.description);
+    info("Starting testcase: " + testcase.description);
 
     markedFieldId = [];
 
     let doc = MockDocument.createTestDocument(
       "http://localhost:8080/test/", testcase.document);
     let element = doc.getElementById(testcase.targetElementId);
     FormAutofillContent.identifyAutofillFields(element);
 
--- a/browser/extensions/formautofill/test/unit/test_masterPassword.js
+++ b/browser/extensions/formautofill/test/unit/test_masterPassword.js
@@ -57,25 +57,25 @@ let gWindowWatcher = {
 };
 
 // Ensure that the appropriate initialization has happened.
 do_get_profile();
 
 let windowWatcherCID =
   MockRegistrar.register("@mozilla.org/embedcomp/window-watcher;1",
                          gWindowWatcher);
-do_register_cleanup(() => {
+registerCleanupFunction(() => {
   MockRegistrar.unregister(windowWatcherCID);
 });
 
 TESTCASES.forEach(testcase => {
   let token = MasterPassword._token;
 
   add_task(async function test_encrypt_decrypt() {
-    do_print("Starting testcase: " + testcase.description);
+    info("Starting testcase: " + testcase.description);
     token.initPassword(testcase.masterPassword);
 
     // Test only: Force the token login without asking for master password
     token.login(/* force */ false);
     Assert.equal(testcase.mpEnabled, token.isLoggedIn(), "Token should now be logged into");
     Assert.equal(MasterPassword.isEnabled, testcase.mpEnabled);
 
     let testText = "test string";
--- a/browser/extensions/formautofill/test/unit/test_migrateRecords.js
+++ b/browser/extensions/formautofill/test/unit/test_migrateRecords.js
@@ -227,37 +227,37 @@ const CREDIT_CARD_TESTCASES = [
       version: undefined,
       "cc-given-name": undefined,
     },
   },
 ];
 
 let do_check_record_matches = (expectedRecord, record) => {
   for (let key in expectedRecord) {
-    do_check_eq(expectedRecord[key], record[key]);
+    Assert.equal(expectedRecord[key], record[key]);
   }
 };
 
 add_task(async function test_migrateAddressRecords() {
   let path = getTempFile(TEST_STORE_FILE_NAME).path;
 
   let profileStorage = new ProfileStorage(path);
   await profileStorage.initialize();
 
   ADDRESS_TESTCASES.forEach(testcase => {
-    do_print(testcase.description);
+    info(testcase.description);
     profileStorage.addresses._migrateRecord(testcase.record);
     do_check_record_matches(testcase.expectedResult, testcase.record);
   });
 });
 
 add_task(async function test_migrateCreditCardRecords() {
   let path = getTempFile(TEST_STORE_FILE_NAME).path;
 
   let profileStorage = new ProfileStorage(path);
   await profileStorage.initialize();
 
   CREDIT_CARD_TESTCASES.forEach(testcase => {
-    do_print(testcase.description);
+    info(testcase.description);
     profileStorage.creditCards._migrateRecord(testcase.record);
     do_check_record_matches(testcase.expectedResult, testcase.record);
   });
 });
--- a/browser/extensions/formautofill/test/unit/test_nameUtils.js
+++ b/browser/extensions/formautofill/test/unit/test_nameUtils.js
@@ -263,22 +263,22 @@ const TESTCASES = [
       family: "문",
     },
   },
 ];
 
 add_task(async function test_splitName() {
   TESTCASES.forEach(testcase => {
     if (testcase.fullName) {
-      do_print("Starting testcase: " + testcase.description);
+      info("Starting testcase: " + testcase.description);
       let nameParts = FormAutofillNameUtils.splitName(testcase.fullName);
       Assert.deepEqual(nameParts, testcase.nameParts);
     }
   });
 });
 
 add_task(async function test_joinName() {
   TESTCASES.forEach(testcase => {
-    do_print("Starting testcase: " + testcase.description);
+    info("Starting testcase: " + testcase.description);
     let name = FormAutofillNameUtils.joinNameParts(testcase.nameParts);
-    do_check_eq(name, testcase.expectedFullName || testcase.fullName);
+    Assert.equal(name, testcase.expectedFullName || testcase.fullName);
   });
 });
--- a/browser/extensions/formautofill/test/unit/test_onFormSubmitted.js
+++ b/browser/extensions/formautofill/test/unit/test_onFormSubmitted.js
@@ -484,17 +484,17 @@ const TESTCASES = [
         }],
         creditCard: [],
       },
     },
   },
 ];
 
 add_task(async function handle_earlyformsubmit_event() {
-  do_print("Starting testcase: Test an invalid form element");
+  info("Starting testcase: Test an invalid form element");
   let fakeForm = MOCK_DOC.createElement("form");
   sinon.spy(FormAutofillContent, "_onFormSubmit");
 
   Assert.equal(FormAutofillContent.notify(fakeForm), true);
   Assert.equal(FormAutofillContent._onFormSubmit.called, false);
   FormAutofillContent._onFormSubmit.restore();
 });
 
@@ -553,17 +553,17 @@ add_task(async function autofill_disable
   FormAutofillContent._onFormSubmit.reset();
   Services.prefs.clearUserPref("extensions.formautofill.creditCards.enabled");
 
   FormAutofillContent._onFormSubmit.restore();
 });
 
 TESTCASES.forEach(testcase => {
   add_task(async function check_records_saving_is_called_correctly() {
-    do_print("Starting testcase: " + testcase.description);
+    info("Starting testcase: " + testcase.description);
 
     let form = MOCK_DOC.getElementById("form1");
     form.reset();
     for (let key in testcase.formValue) {
       let input = MOCK_DOC.getElementById(key);
       let value = testcase.formValue[key];
 
       if (ChromeUtils.getClassName(input) === "HTMLSelectElement" && value) {
--- a/browser/extensions/formautofill/test/unit/test_phoneNumber.js
+++ b/browser/extensions/formautofill/test/unit/test_phoneNumber.js
@@ -4,56 +4,56 @@
 
 "use strict";
 
 Cu.import("resource://formautofill/phonenumberutils/PhoneNumber.jsm");
 Cu.import("resource://formautofill/phonenumberutils/PhoneNumberNormalizer.jsm");
 
 function IsPlain(dial, expected) {
   let result = PhoneNumber.IsPlain(dial);
-  do_check_eq(result, expected);
+  Assert.equal(result, expected);
 }
 
 function Normalize(dial, expected) {
   let result = PhoneNumberNormalizer.Normalize(dial);
-  do_check_eq(result, expected);
+  Assert.equal(result, expected);
 }
 
 function CantParse(dial, currentRegion) {
   let result = PhoneNumber.Parse(dial, currentRegion);
-  do_check_null(result);
+  Assert.equal(null, result);
 }
 
 function Parse(dial, currentRegion) {
   let result = PhoneNumber.Parse(dial, currentRegion);
-  do_check_neq(result, null);
+  Assert.notEqual(result, null);
   return result;
 }
 
 function Test(dial, currentRegion, nationalNumber, region) {
   let result = Parse(dial, currentRegion);
-  do_check_eq(result.nationalNumber, nationalNumber);
-  do_check_eq(result.region, region);
+  Assert.equal(result.nationalNumber, nationalNumber);
+  Assert.equal(result.region, region);
   return result;
 }
 
 function TestProperties(dial, currentRegion) {
   let result = Parse(dial, currentRegion);
-  do_check_true(result.internationalFormat);
-  do_check_true(result.internationalNumber);
-  do_check_true(result.nationalFormat);
-  do_check_true(result.nationalNumber);
-  do_check_true(result.countryName);
-  do_check_true(result.countryCode);
+  Assert.ok(result.internationalFormat);
+  Assert.ok(result.internationalNumber);
+  Assert.ok(result.nationalFormat);
+  Assert.ok(result.nationalNumber);
+  Assert.ok(result.countryName);
+  Assert.ok(result.countryCode);
 }
 
 function Format(dial, currentRegion, nationalNumber, region, nationalFormat, internationalFormat) {
   let result = Test(dial, currentRegion, nationalNumber, region);
-  do_check_eq(result.nationalFormat, nationalFormat);
-  do_check_eq(result.internationalFormat, internationalFormat);
+  Assert.equal(result.nationalFormat, nationalFormat);
+  Assert.equal(result.internationalFormat, internationalFormat);
   return result;
 }
 
 function AllEqual(list, currentRegion) {
   let parsedList = list.map(item => Parse(item, currentRegion));
   let firstItem = parsedList.shift();
   for (let item of parsedList) {
     Assert.deepEqual(item, firstItem);
@@ -235,12 +235,12 @@ add_task(async function test_phoneNumber
   Normalize("+ABC # * , 9 _ 1 _0", "+222#*,910");
   Normalize("ABCDEFGHIJKLMNOPQRSTUVWXYZ", "22233344455566677778889999");
   Normalize("abcdefghijklmnopqrstuvwxyz", "22233344455566677778889999");
 
   // 8 and 9 digit numbers with area code in Brazil with collect call prefix (90)
   AllEqual(["01187654321", "0411187654321", "551187654321", "90411187654321", "+551187654321"], "BR");
   AllEqual(["011987654321", "04111987654321", "5511987654321", "904111987654321", "+5511987654321"], "BR");
 
-  do_check_eq(PhoneNumberNormalizer.Normalize("123abc", true), "123");
-  do_check_eq(PhoneNumberNormalizer.Normalize("12345", true), "12345");
-  do_check_eq(PhoneNumberNormalizer.Normalize("1abcd", false), "12223");
+  Assert.equal(PhoneNumberNormalizer.Normalize("123abc", true), "123");
+  Assert.equal(PhoneNumberNormalizer.Normalize("12345", true), "12345");
+  Assert.equal(PhoneNumberNormalizer.Normalize("1abcd", false), "12223");
 });
--- a/browser/extensions/formautofill/test/unit/test_profileAutocompleteResult.js
+++ b/browser/extensions/formautofill/test/unit/test_profileAutocompleteResult.js
@@ -346,17 +346,17 @@ let testSets = [{
 }, {
   collectionConstructor: CreditCardResult,
   testCases: creditCardTestCases,
 }];
 
 add_task(async function test_all_patterns() {
   testSets.forEach(({collectionConstructor, testCases}) => {
     testCases.forEach(testCase => {
-      do_print("Starting testcase: " + testCase.description);
+      info("Starting testcase: " + testCase.description);
       let actual = new collectionConstructor(testCase.searchString,
                                              testCase.fieldName,
                                              testCase.allFieldNames,
                                              testCase.matchingProfiles,
                                              testCase.options);
       let expectedValue = testCase.expected;
       let expectedItemLength = expectedValue.items.length;
       // If the last item shows up as a footer, we expect one more item
--- a/browser/extensions/formautofill/test/unit/test_reconcile.js
+++ b/browser/extensions/formautofill/test/unit/test_reconcile.js
@@ -989,22 +989,22 @@ add_task(async function test_reconcile_i
 
 add_task(async function test_reconcile_three_way_merge() {
   let TESTCASES = {
     addresses: ADDRESS_RECONCILE_TESTCASES,
     creditCards: CREDIT_CARD_RECONCILE_TESTCASES,
   };
 
   for (let collectionName in TESTCASES) {
-    do_print(`Start to test reconcile on ${collectionName}`);
+    info(`Start to test reconcile on ${collectionName}`);
 
     let profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME, null, collectionName);
 
     for (let test of TESTCASES[collectionName]) {
-      do_print(test.description);
+      info(test.description);
 
       profileStorage[collectionName].add(test.parent, {sourceSync: true});
 
       for (let updatedRecord of test.local) {
         profileStorage[collectionName].update(test.parent.guid, updatedRecord);
       }
 
       let localRecord = profileStorage[collectionName].get(test.parent.guid, {
--- a/browser/extensions/formautofill/test/unit/test_savedFieldNames.js
+++ b/browser/extensions/formautofill/test/unit/test_savedFieldNames.js
@@ -8,52 +8,52 @@ let {FormAutofillParent} = Cu.import("re
 Cu.import("resource://formautofill/ProfileStorage.jsm");
 
 add_task(async function test_profileSavedFieldNames_init() {
   let formAutofillParent = new FormAutofillParent();
   sinon.stub(formAutofillParent, "_updateSavedFieldNames");
 
   await formAutofillParent.init();
   await formAutofillParent.profileStorage.initialize();
-  do_check_eq(formAutofillParent._updateSavedFieldNames.called, true);
+  Assert.equal(formAutofillParent._updateSavedFieldNames.called, true);
 
   formAutofillParent._uninit();
 });
 
 add_task(async function test_profileSavedFieldNames_observe() {
   let formAutofillParent = new FormAutofillParent();
   sinon.stub(formAutofillParent, "_updateSavedFieldNames");
 
   await formAutofillParent.init();
 
   // profile changed => Need to trigger updateValidFields
   ["add", "update", "remove", "reconcile"].forEach(event => {
     formAutofillParent.observe(null, "formautofill-storage-changed", "add");
-    do_check_eq(formAutofillParent._updateSavedFieldNames.called, true);
+    Assert.equal(formAutofillParent._updateSavedFieldNames.called, true);
   });
 
   // profile metadata updated => no need to trigger updateValidFields
   formAutofillParent._updateSavedFieldNames.reset();
   formAutofillParent.observe(null, "formautofill-storage-changed", "notifyUsed");
-  do_check_eq(formAutofillParent._updateSavedFieldNames.called, false);
+  Assert.equal(formAutofillParent._updateSavedFieldNames.called, false);
 });
 
 add_task(async function test_profileSavedFieldNames_update() {
   let formAutofillParent = new FormAutofillParent();
   await formAutofillParent.init();
-  do_register_cleanup(function cleanup() {
+  registerCleanupFunction(function cleanup() {
     Services.prefs.clearUserPref("extensions.formautofill.addresses.enabled");
   });
 
   sinon.stub(profileStorage.addresses, "getAll");
   profileStorage.addresses.getAll.returns([]);
 
   // The set is empty if there's no profile in the store.
   formAutofillParent._updateSavedFieldNames();
-  do_check_eq(Services.ppmm.initialProcessData.autofillSavedFieldNames.size, 0);
+  Assert.equal(Services.ppmm.initialProcessData.autofillSavedFieldNames.size, 0);
 
   // 2 profiles with 4 valid fields.
   let fakeStorage = [{
     guid: "test-guid-1",
     organization: "Sesame Street",
     "street-address": "123 Sesame Street.",
     tel: "1-345-345-3456",
     email: "",
@@ -71,19 +71,19 @@ add_task(async function test_profileSave
     timeLastUsed: 0,
     timeLastModified: 0,
     timesUsed: 0,
   }];
   profileStorage.addresses.getAll.returns(fakeStorage);
   formAutofillParent._updateSavedFieldNames();
 
   let autofillSavedFieldNames = Services.ppmm.initialProcessData.autofillSavedFieldNames;
-  do_check_eq(autofillSavedFieldNames.size, 4);
-  do_check_eq(autofillSavedFieldNames.has("organization"), true);
-  do_check_eq(autofillSavedFieldNames.has("street-address"), true);
-  do_check_eq(autofillSavedFieldNames.has("tel"), true);
-  do_check_eq(autofillSavedFieldNames.has("email"), false);
-  do_check_eq(autofillSavedFieldNames.has("guid"), false);
-  do_check_eq(autofillSavedFieldNames.has("timeCreated"), false);
-  do_check_eq(autofillSavedFieldNames.has("timeLastUsed"), false);
-  do_check_eq(autofillSavedFieldNames.has("timeLastModified"), false);
-  do_check_eq(autofillSavedFieldNames.has("timesUsed"), false);
+  Assert.equal(autofillSavedFieldNames.size, 4);
+  Assert.equal(autofillSavedFieldNames.has("organization"), true);
+  Assert.equal(autofillSavedFieldNames.has("street-address"), true);
+  Assert.equal(autofillSavedFieldNames.has("tel"), true);
+  Assert.equal(autofillSavedFieldNames.has("email"), false);
+  Assert.equal(autofillSavedFieldNames.has("guid"), false);
+  Assert.equal(autofillSavedFieldNames.has("timeCreated"), false);
+  Assert.equal(autofillSavedFieldNames.has("timeLastUsed"), false);
+  Assert.equal(autofillSavedFieldNames.has("timeLastModified"), false);
+  Assert.equal(autofillSavedFieldNames.has("timesUsed"), false);
 });
--- a/browser/extensions/formautofill/test/unit/test_storage_syncfields.js
+++ b/browser/extensions/formautofill/test/unit/test_storage_syncfields.js
@@ -74,37 +74,37 @@ add_task(async function test_pushChanges
   };
 
   let onChanged = TestUtils.topicObserved("formautofill-storage-changed",
                                           (subject, data) => data == "update");
   profileStorage.addresses.update(guid, TEST_ADDRESS_3);
   await onChanged;
 
   changeCounter = getSyncChangeCounter(profileStorage.addresses, guid);
-  do_check_eq(changeCounter, 2);
+  Assert.equal(changeCounter, 2);
 
   profileStorage.addresses.pushSyncChanges(changes);
   address = profileStorage.addresses.get(guid);
   changeCounter = getSyncChangeCounter(profileStorage.addresses, guid);
 
   // Counter should still be 1, since our sync didn't record the mid-sync change
-  do_check_eq(changeCounter, 1, "Counter shouldn't be zero because it didn't record update");
+  Assert.equal(changeCounter, 1, "Counter shouldn't be zero because it didn't record update");
 
   // now, push a new set of changes, which should make the changeCounter 0
   profileStorage.addresses.pushSyncChanges({
     [guid]: {
       profile: address,
       counter: changeCounter,
       modified: address.timeLastModified,
       synced: true,
     },
   });
 
   changeCounter = getSyncChangeCounter(profileStorage.addresses, guid);
-  do_check_eq(changeCounter, 0);
+  Assert.equal(changeCounter, 0);
 });
 
 async function checkingSyncChange(action, callback) {
   let onChanged = TestUtils.topicObserved("formautofill-storage-changed",
                                           (subject, data) => data == action);
   await callback();
   let [subject] = await onChanged;
   ok(subject.wrappedJSObject.sourceSync, "change notification should have source sync");
--- a/browser/extensions/formautofill/test/unit/test_storage_tombstones.js
+++ b/browser/extensions/formautofill/test/unit/test_storage_tombstones.js
@@ -46,39 +46,39 @@ function add_storage_task(test_function)
     for (let [storage, record] of [[profileStorage.addresses, TEST_ADDRESS_1],
                                    [profileStorage.creditCards, testCC1]]) {
       await test_function(storage, record);
     }
   });
 }
 
 add_storage_task(async function test_simple_tombstone(storage, record) {
-  do_print("check simple tombstone semantics");
+  info("check simple tombstone semantics");
 
   let guid = storage.add(record);
-  do_check_eq(storage.getAll().length, 1);
+  Assert.equal(storage.getAll().length, 1);
 
   storage.remove(guid);
 
   // should be unable to get it normally.
   Assert.equal(storage.get(guid), null);
   // and getAll should also not return it.
   Assert.equal(storage.getAll().length, 0);
 
   // but getAll allows us to access deleted items - but we didn't create
   // a tombstone here, so even that will not get it.
   let all = storage.getAll({includeDeleted: true});
   Assert.equal(all.length, 0);
 });
 
 add_storage_task(async function test_simple_synctombstone(storage, record) {
-  do_print("check simple tombstone semantics for synced records");
+  info("check simple tombstone semantics for synced records");
 
   let guid = storage.add(record);
-  do_check_eq(storage.getAll().length, 1);
+  Assert.equal(storage.getAll().length, 1);
 
   storage.pullSyncChanges(); // force sync metadata, which triggers tombstone behaviour.
 
   storage.remove(guid);
 
   // should be unable to get it normally.
   Assert.equal(storage.get(guid), null);
   // and getAll should also not return it.
@@ -93,17 +93,17 @@ add_storage_task(async function test_sim
   // a tombstone got from API should look exactly the same as it got from the
   // disk (besides "_sync").
   let tombstoneInDisk = Object.assign({}, storage._store.data[storage._collectionName][0]);
   delete tombstoneInDisk._sync;
   do_check_tombstone_record(tombstoneInDisk);
 });
 
 add_storage_task(async function test_add_tombstone(storage, record) {
-  do_print("Should be able to add a new tombstone");
+  info("Should be able to add a new tombstone");
   let guid = storage.add({guid: "test-guid-1", deleted: true});
 
   // should be unable to get it normally.
   Assert.equal(storage.get(guid), null);
   // and getAll should also not return it.
   Assert.equal(storage.getAll().length, 0);
 
   // but getAll allows us to access deleted items.
@@ -115,39 +115,39 @@ add_storage_task(async function test_add
   // a tombstone got from API should look exactly the same as it got from the
   // disk (besides "_sync").
   let tombstoneInDisk = Object.assign({}, storage._store.data[storage._collectionName][0]);
   delete tombstoneInDisk._sync;
   do_check_tombstone_record(tombstoneInDisk);
 });
 
 add_storage_task(async function test_add_tombstone_without_guid(storage, record) {
-  do_print("Should not be able to add a new tombstone without specifying the guid");
+  info("Should not be able to add a new tombstone without specifying the guid");
   Assert.throws(() => { storage.add({deleted: true}); });
   Assert.equal(storage.getAll({includeDeleted: true}).length, 0);
 });
 
 add_storage_task(async function test_add_tombstone_existing_guid(storage, record) {
-  do_print("Should not be able to add a new tombstone when a record with that ID exists");
+  info("Should not be able to add a new tombstone when a record with that ID exists");
   let guid = storage.add(record);
   Assert.throws(() => { storage.add({guid, deleted: true}); });
 
   // same if the existing item is already a tombstone.
   storage.add({guid: "test-guid-1", deleted: true});
   Assert.throws(() => { storage.add({guid: "test-guid-1", deleted: true}); });
 });
 
 add_storage_task(async function test_update_tombstone(storage, record) {
-  do_print("Updating a tombstone should fail");
+  info("Updating a tombstone should fail");
   let guid = storage.add({guid: "test-guid-1", deleted: true});
   Assert.throws(() => storage.update(guid, {}), /No matching record./);
 });
 
 add_storage_task(async function test_remove_existing_tombstone(storage, record) {
-  do_print("Removing a record that's already a tombstone should be a no-op");
+  info("Removing a record that's already a tombstone should be a no-op");
   let guid = storage.add({guid: "test-guid-1", deleted: true, timeLastModified: 1234});
 
   storage.remove(guid);
   let all = storage.getAll({rawData: true, includeDeleted: true});
   Assert.equal(all.length, 1);
 
   do_check_tombstone_record(all[0]);
   equal(all[0].timeLastModified, 1234); // should not be updated to now().
--- a/browser/extensions/formautofill/test/unit/test_sync.js
+++ b/browser/extensions/formautofill/test/unit/test_sync.js
@@ -53,20 +53,20 @@ function expectLocalProfiles(profileStor
     for (let i = 0; i < expected.length; i++) {
       let thisExpected = expected[i];
       let thisGot = profiles[i];
       // always check "deleted".
       equal(thisExpected.deleted, thisGot.deleted);
       ok(objectMatches(thisGot, thisExpected));
     }
   } catch (ex) {
-    do_print("Comparing expected profiles:");
-    do_print(JSON.stringify(expected, undefined, 2));
-    do_print("against actual profiles:");
-    do_print(JSON.stringify(profiles, undefined, 2));
+    info("Comparing expected profiles:");
+    info(JSON.stringify(expected, undefined, 2));
+    info("against actual profiles:");
+    info(JSON.stringify(profiles, undefined, 2));
     throw ex;
   }
 }
 
 async function setup() {
   let profileStorage = await initProfileStorage(TEST_STORE_FILE_NAME);
   // should always start with no profiles.
   Assert.equal(profileStorage.addresses.getAll({includeDeleted: true}).length, 0);
--- a/browser/extensions/formautofill/test/unit/test_transformFields.js
+++ b/browser/extensions/formautofill/test/unit/test_transformFields.js
@@ -829,79 +829,79 @@ const CREDIT_CARD_NORMALIZE_TESTCASES = 
       "cc-exp-month": 12,
       "cc-exp-year": 2022,
     },
   },
 ];
 
 let do_check_record_matches = (expectedRecord, record) => {
   for (let key in expectedRecord) {
-    do_check_eq(expectedRecord[key], record[key]);
+    Assert.equal(expectedRecord[key], record[key]);
   }
 };
 
 add_task(async function test_computeAddressFields() {
   let path = getTempFile(TEST_STORE_FILE_NAME).path;
 
   let profileStorage = new ProfileStorage(path);
   await profileStorage.initialize();
 
   ADDRESS_COMPUTE_TESTCASES.forEach(testcase => {
-    do_print("Verify testcase: " + testcase.description);
+    info("Verify testcase: " + testcase.description);
 
     let guid = profileStorage.addresses.add(testcase.address);
     let address = profileStorage.addresses.get(guid);
     do_check_record_matches(testcase.expectedResult, address);
 
     profileStorage.addresses.remove(guid);
   });
 });
 
 add_task(async function test_normalizeAddressFields() {
   let path = getTempFile(TEST_STORE_FILE_NAME).path;
 
   let profileStorage = new ProfileStorage(path);
   await profileStorage.initialize();
 
   ADDRESS_NORMALIZE_TESTCASES.forEach(testcase => {
-    do_print("Verify testcase: " + testcase.description);
+    info("Verify testcase: " + testcase.description);
 
     let guid = profileStorage.addresses.add(testcase.address);
     let address = profileStorage.addresses.get(guid);
     do_check_record_matches(testcase.expectedResult, address);
 
     profileStorage.addresses.remove(guid);
   });
 });
 
 add_task(async function test_computeCreditCardFields() {
   let path = getTempFile(TEST_STORE_FILE_NAME).path;
 
   let profileStorage = new ProfileStorage(path);
   await profileStorage.initialize();
 
   CREDIT_CARD_COMPUTE_TESTCASES.forEach(testcase => {
-    do_print("Verify testcase: " + testcase.description);
+    info("Verify testcase: " + testcase.description);
 
     let guid = profileStorage.creditCards.add(testcase.creditCard);
     let creditCard = profileStorage.creditCards.get(guid);
     do_check_record_matches(testcase.expectedResult, creditCard);
 
     profileStorage.creditCards.remove(guid);
   });
 });
 
 add_task(async function test_normalizeCreditCardFields() {
   let path = getTempFile(TEST_STORE_FILE_NAME).path;
 
   let profileStorage = new ProfileStorage(path);
   await profileStorage.initialize();
 
   CREDIT_CARD_NORMALIZE_TESTCASES.forEach(testcase => {
-    do_print("Verify testcase: " + testcase.description);
+    info("Verify testcase: " + testcase.description);
 
     let guid = profileStorage.creditCards.add(testcase.creditCard);
     let creditCard = profileStorage.creditCards.get(guid, {rawData: true});
     do_check_record_matches(testcase.expectedResult, creditCard);
 
     profileStorage.creditCards.remove(guid);
   });
 });
--- a/browser/extensions/mortar/test/unit/head.js
+++ b/browser/extensions/mortar/test/unit/head.js
@@ -48,12 +48,12 @@ function Call_PpbFunc(obj) {
   }
   let fn = obj.__interface + "_" + obj.__method;
   return rt.table[fn](obj);
 }
 
 // PPAPIInstance constructor(id, rt, info, window, eventHandler, containerWindow, mm)
 let instance = new PPAPIInstance(instanceId, rt, info, new Mock_Window(), null /*docShell.chromeEventHandler*/, null, new Mock_MessageManager());
 
-do_register_cleanup(function () {
+registerCleanupFunction(function () {
   resHandler.setSubstitution("ppapi.js", null);
 })
 
--- a/browser/extensions/onboarding/test/unit/test-onboarding-tour-type.js
+++ b/browser/extensions/onboarding/test/unit/test-onboarding-tour-type.js
@@ -2,88 +2,88 @@
  * Test for onboarding tour type check.
  */
 
 "use strict";
 
 Cu.import("resource://onboarding/modules/OnboardingTourType.jsm");
 
 add_task(async function() {
-  do_print("Starting testcase: When New user open the browser first time");
+  info("Starting testcase: When New user open the browser first time");
   resetOnboardingDefaultState();
   OnboardingTourType.check();
 
-  do_check_eq(Preferences.get(PREF_TOUR_TYPE), "new", "should show the new user tour");
-  do_check_eq(Preferences.get(PREF_TOURSET_VERSION), TOURSET_VERSION,
+  Assert.equal(Preferences.get(PREF_TOUR_TYPE), "new", "should show the new user tour");
+  Assert.equal(Preferences.get(PREF_TOURSET_VERSION), TOURSET_VERSION,
     "tourset version should not change");
-  do_check_eq(Preferences.get(PREF_SEEN_TOURSET_VERSION), TOURSET_VERSION,
+  Assert.equal(Preferences.get(PREF_SEEN_TOURSET_VERSION), TOURSET_VERSION,
     "seen tourset version should be set as the tourset version");
 });
 
 add_task(async function() {
-  do_print("Starting testcase: When New user restart the browser");
+  info("Starting testcase: When New user restart the browser");
   resetOnboardingDefaultState();
   Preferences.set(PREF_TOUR_TYPE, "new");
   Preferences.set(PREF_SEEN_TOURSET_VERSION, TOURSET_VERSION);
   OnboardingTourType.check();
 
-  do_check_eq(Preferences.get(PREF_TOUR_TYPE), "new", "should show the new user tour");
-  do_check_eq(Preferences.get(PREF_TOURSET_VERSION), TOURSET_VERSION,
+  Assert.equal(Preferences.get(PREF_TOUR_TYPE), "new", "should show the new user tour");
+  Assert.equal(Preferences.get(PREF_TOURSET_VERSION), TOURSET_VERSION,
     "tourset version should not change");
-  do_check_eq(Preferences.get(PREF_SEEN_TOURSET_VERSION), TOURSET_VERSION,
+  Assert.equal(Preferences.get(PREF_SEEN_TOURSET_VERSION), TOURSET_VERSION,
     "seen tourset version should be set as the tourset version");
 });
 
 add_task(async function() {
-  do_print("Starting testcase: When New User choosed to hide the overlay and restart the browser");
+  info("Starting testcase: When New User choosed to hide the overlay and restart the browser");
   resetOnboardingDefaultState();
   Preferences.set(PREF_TOUR_TYPE, "new");
   Preferences.set(PREF_SEEN_TOURSET_VERSION, TOURSET_VERSION);
   OnboardingTourType.check();
 
-  do_check_eq(Preferences.get(PREF_TOUR_TYPE), "new", "should show the new user tour");
-  do_check_eq(Preferences.get(PREF_TOURSET_VERSION), TOURSET_VERSION,
+  Assert.equal(Preferences.get(PREF_TOUR_TYPE), "new", "should show the new user tour");
+  Assert.equal(Preferences.get(PREF_TOURSET_VERSION), TOURSET_VERSION,
     "tourset version should not change");
-  do_check_eq(Preferences.get(PREF_SEEN_TOURSET_VERSION), TOURSET_VERSION,
+  Assert.equal(Preferences.get(PREF_SEEN_TOURSET_VERSION), TOURSET_VERSION,
     "seen tourset version should be set as the tourset version");
 });
 
 add_task(async function() {
-  do_print("Starting testcase: When New User updated to the next major version and restart the browser");
+  info("Starting testcase: When New User updated to the next major version and restart the browser");
   resetOnboardingDefaultState();
   Preferences.set(PREF_TOURSET_VERSION, NEXT_TOURSET_VERSION);
   Preferences.set(PREF_TOUR_TYPE, "new");
   Preferences.set(PREF_SEEN_TOURSET_VERSION, TOURSET_VERSION);
   OnboardingTourType.check();
 
-  do_check_eq(Preferences.get(PREF_TOUR_TYPE), "update", "should show the update user tour");
-  do_check_eq(Preferences.get(PREF_TOURSET_VERSION), NEXT_TOURSET_VERSION,
+  Assert.equal(Preferences.get(PREF_TOUR_TYPE), "update", "should show the update user tour");
+  Assert.equal(Preferences.get(PREF_TOURSET_VERSION), NEXT_TOURSET_VERSION,
     "tourset version should not change");
-  do_check_eq(Preferences.get(PREF_SEEN_TOURSET_VERSION), NEXT_TOURSET_VERSION,
+  Assert.equal(Preferences.get(PREF_SEEN_TOURSET_VERSION), NEXT_TOURSET_VERSION,
     "seen tourset version should be set as the tourset version");
 });
 
 add_task(async function() {
-  do_print("Starting testcase: When New User prefer hide the tour, then updated to the next major version and restart the browser");
+  info("Starting testcase: When New User prefer hide the tour, then updated to the next major version and restart the browser");
   resetOnboardingDefaultState();
   Preferences.set(PREF_TOURSET_VERSION, NEXT_TOURSET_VERSION);
   Preferences.set(PREF_TOUR_TYPE, "new");
   Preferences.set(PREF_SEEN_TOURSET_VERSION, TOURSET_VERSION);
   OnboardingTourType.check();
 
-  do_check_eq(Preferences.get(PREF_TOUR_TYPE), "update", "should show the update user tour");
-  do_check_eq(Preferences.get(PREF_TOURSET_VERSION), NEXT_TOURSET_VERSION,
+  Assert.equal(Preferences.get(PREF_TOUR_TYPE), "update", "should show the update user tour");
+  Assert.equal(Preferences.get(PREF_TOURSET_VERSION), NEXT_TOURSET_VERSION,
     "tourset version should not change");
-  do_check_eq(Preferences.get(PREF_SEEN_TOURSET_VERSION), NEXT_TOURSET_VERSION,
+  Assert.equal(Preferences.get(PREF_SEEN_TOURSET_VERSION), NEXT_TOURSET_VERSION,
     "seen tourset version should be set as the tourset version");
 });
 
 add_task(async function() {
-  do_print("Starting testcase: When User update from browser version < 56");
+  info("Starting testcase: When User update from browser version < 56");
   resetOldProfileDefaultState();
   OnboardingTourType.check();
 
-  do_check_eq(Preferences.get(PREF_TOUR_TYPE), "update", "should show the update user tour");
-  do_check_eq(Preferences.get(PREF_TOURSET_VERSION), TOURSET_VERSION,
+  Assert.equal(Preferences.get(PREF_TOUR_TYPE), "update", "should show the update user tour");
+  Assert.equal(Preferences.get(PREF_TOURSET_VERSION), TOURSET_VERSION,
     "tourset version should not change");
-  do_check_eq(Preferences.get(PREF_SEEN_TOURSET_VERSION), TOURSET_VERSION,
+  Assert.equal(Preferences.get(PREF_SEEN_TOURSET_VERSION), TOURSET_VERSION,
     "seen tourset version should be set as the tourset version");
 });
deleted file mode 100644
--- a/browser/locales/en-US/chrome/browser/preferences/donottrack.dtd
+++ /dev/null
@@ -1,13 +0,0 @@
-<!-- This Source Code Form is subject to the terms of the Mozilla Public
-   - License, v. 2.0. If a copy of the MPL was not distributed with this
-   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
-
-<!ENTITY window.title                 "Do Not Track">
-<!ENTITY window.width                 "50em">
-<!ENTITY window.height                "10em">
-
-<!ENTITY doNotTrackCheckbox2.label    "Always apply Do Not Track">
-<!ENTITY doNotTrackCheckbox2.accesskey "A">
-
-<!ENTITY doNotTrackTPInfo.description "&brandShortName; will send a signal that you don’t want to be tracked whenever Tracking Protection is on.">
-<!ENTITY doNotTrackLearnMore.label    "Learn More">
--- a/browser/locales/jar.mn
+++ b/browser/locales/jar.mn
@@ -67,17 +67,16 @@
     locale/browser/preferences/applications.dtd       (%chrome/browser/preferences/applications.dtd)
     locale/browser/preferences/blocklists.dtd         (%chrome/browser/preferences/blocklists.dtd)
     locale/browser/preferences/colors.dtd             (%chrome/browser/preferences/colors.dtd)
     locale/browser/preferences/connection.dtd         (%chrome/browser/preferences/connection.dtd)
     locale/browser/preferences/containers.dtd         (%chrome/browser/preferences/containers.dtd)
     locale/browser/preferences/containers.properties     (%chrome/browser/preferences/containers.properties)
     locale/browser/preferences/content.dtd            (%chrome/browser/preferences/content.dtd)
     locale/browser/preferences/cookies.dtd            (%chrome/browser/preferences/cookies.dtd)
-    locale/browser/preferences/donottrack.dtd         (%chrome/browser/preferences/donottrack.dtd)
     locale/browser/preferences/fonts.dtd              (%chrome/browser/preferences/fonts.dtd)
     locale/browser/preferences/languages.dtd          (%chrome/browser/preferences/languages.dtd)
     locale/browser/preferences/main.dtd               (%chrome/browser/preferences/main.dtd)
     locale/browser/preferences/permissions.dtd        (%chrome/browser/preferences/permissions.dtd)
     locale/browser/preferences/preferences.dtd        (%chrome/browser/preferences/preferences.dtd)
     locale/browser/preferences/preferences.properties     (%chrome/browser/preferences/preferences.properties)
     locale/browser/preferences/privacy.dtd            (%chrome/browser/preferences/privacy.dtd)
     locale/browser/preferences/search.dtd             (%chrome/browser/preferences/search.dtd)
--- a/browser/modules/test/unit/test_DirectoryLinksProvider.js
+++ b/browser/modules/test/unit/test_DirectoryLinksProvider.js
@@ -70,27 +70,27 @@ function getHttpHandler(path) {
     aResponse.setStatusLine(null, code);
     aResponse.setHeader("Content-Type", "application/json");
     aResponse.write(body);
   };
 }
 
 function isIdentical(actual, expected) {
   if (expected == null) {
-    do_check_eq(actual, expected);
+    Assert.equal(actual, expected);
   } else if (typeof expected == "object") {
     // Make sure all the keys match up
-    do_check_eq(Object.keys(actual).sort() + "", Object.keys(expected).sort());
+    Assert.equal(Object.keys(actual).sort() + "", Object.keys(expected).sort());
 
     // Recursively check each value individually
     Object.keys(expected).forEach(key => {
       isIdentical(actual[key], expected[key]);
     });
   } else {
-    do_check_eq(actual, expected);
+    Assert.equal(actual, expected);
   }
 }
 
 function fetchData() {
   return new Promise(resolve => {
 
     DirectoryLinksProvider.getLinks(linkData => {
       resolve(linkData);
@@ -135,17 +135,17 @@ function promiseDirectoryDownloadOnPrefC
 }
 
 function promiseSetupDirectoryLinksProvider(options = {}) {
   return (async function() {
     let linksURL = options.linksURL || kTestURL;
     await DirectoryLinksProvider.init();
     Services.locale.setRequestedLocales([options.locale || "en-US"]);
     await promiseDirectoryDownloadOnPrefChange(kSourceUrlPref, linksURL);
-    do_check_eq(DirectoryLinksProvider._linksURL, linksURL);
+    Assert.equal(DirectoryLinksProvider._linksURL, linksURL);
     DirectoryLinksProvider._lastDownloadMS = options.lastDownloadMS || 0;
   })();
 }
 
 function promiseCleanDirectoryLinksProvider() {
   return (async function() {
     Services.locale.setRequestedLocales(["en-US"]);
     await promiseDirectoryDownloadOnPrefChange(kSourceUrlPref, kTestURL);
@@ -160,17 +160,17 @@ function run_test() {
   server.registerPrefixHandler(kExamplePath, getHttpHandler(kExamplePath));
   server.registerPrefixHandler(kFailPath, getHttpHandler(kFailPath));
   server.start(kDefaultServerPort);
   NewTabUtils.init();
 
   run_next_test();
 
   // Teardown.
-  do_register_cleanup(function() {
+  registerCleanupFunction(function() {
     server.stop(function() { });
     DirectoryLinksProvider.reset();
     Services.locale.setRequestedLocales(origReqLocales);
     Services.prefs.clearUserPref(kSourceUrlPref);
     Services.prefs.clearUserPref(kNewtabEnhancedPref);
   });
 }
 
@@ -197,92 +197,92 @@ add_task(async function test_fetchAndCac
   isIdentical(data, kURLData);
 });
 
 add_task(async function test_fetchAndCacheLinks_remote() {
   await DirectoryLinksProvider.init();
   await cleanJsonFile();
   // this must trigger directory links json download and save it to cache file
   await promiseDirectoryDownloadOnPrefChange(kSourceUrlPref, kExampleURL + "%LOCALE%");
-  do_check_eq(gLastRequestPath, kExamplePath + "en-US");
+  Assert.equal(gLastRequestPath, kExamplePath + "en-US");
   let data = await readJsonFile();
   isIdentical(data, kHttpHandlerData[kExamplePath]);
 });
 
 add_task(async function test_fetchAndCacheLinks_malformedURI() {
   await DirectoryLinksProvider.init();
   await cleanJsonFile();
   let someJunk = "some junk";
   try {
     await DirectoryLinksProvider._fetchAndCacheLinks(someJunk);
     do_throw("Malformed URIs should fail");
   } catch (e) {
-    do_check_eq(e, "Error fetching " + someJunk);
+    Assert.equal(e, "Error fetching " + someJunk);
   }
 
   // File should be empty.
   let data = await readJsonFile();
   isIdentical(data, "");
 });
 
 add_task(async function test_fetchAndCacheLinks_unknownHost() {
   await DirectoryLinksProvider.init();
   await cleanJsonFile();
   let nonExistentServer = "http://localhost:56789/";
   try {
     await DirectoryLinksProvider._fetchAndCacheLinks(nonExistentServer);
     do_throw("BAD URIs should fail");
   } catch (e) {
-    do_check_true(e.startsWith("Fetching " + nonExistentServer + " results in error code: "));
+    Assert.ok(e.startsWith("Fetching " + nonExistentServer + " results in error code: "));
   }
 
   // File should be empty.
   let data = await readJsonFile();
   isIdentical(data, "");
 });
 
 add_task(async function test_fetchAndCacheLinks_non200Status() {
   await DirectoryLinksProvider.init();
   await cleanJsonFile();
   await promiseDirectoryDownloadOnPrefChange(kSourceUrlPref, kFailURL);
-  do_check_eq(gLastRequestPath, kFailPath);
+  Assert.equal(gLastRequestPath, kFailPath);
   let data = await readJsonFile();
   isIdentical(data, {});
 });
 
 // To test onManyLinksChanged observer, trigger a fetch
 add_task(async function test_DirectoryLinksProvider__linkObservers() {
   await DirectoryLinksProvider.init();
 
   let testObserver = new LinksChangeObserver();
   DirectoryLinksProvider.addObserver(testObserver);
-  do_check_eq(DirectoryLinksProvider._observers.size, 1);
+  Assert.equal(DirectoryLinksProvider._observers.size, 1);
   DirectoryLinksProvider._fetchAndCacheLinksIfNecessary(true);
 
   await testObserver.deferred.promise;
   DirectoryLinksProvider._removeObservers();
-  do_check_eq(DirectoryLinksProvider._observers.size, 0);
+  Assert.equal(DirectoryLinksProvider._observers.size, 0);
 
   await promiseCleanDirectoryLinksProvider();
 });
 
 add_task(async function test_DirectoryLinksProvider__prefObserver_url() {
   await promiseSetupDirectoryLinksProvider({linksURL: kTestURL});
 
   let links = await fetchData();
-  do_check_eq(links.length, 1);
+  Assert.equal(links.length, 1);
   let expectedData =  [{url: "http://example.com", title: "LocalSource", frecency: DIRECTORY_FRECENCY, lastVisitDate: 1}];
   isIdentical(links, expectedData);
 
   // tests these 2 things:
   // 1. _linksURL is properly set after the pref change
   // 2. invalid source url is correctly handled
   let exampleUrl = "http://localhost:56789/bad";
   await promiseDirectoryDownloadOnPrefChange(kSourceUrlPref, exampleUrl);
-  do_check_eq(DirectoryLinksProvider._linksURL, exampleUrl);
+  Assert.equal(DirectoryLinksProvider._linksURL, exampleUrl);
 
   // since the download fail, the directory file must remain the same
   let newLinks = await fetchData();
   isIdentical(newLinks, expectedData);
 
   // now remove the file, and re-download
   await cleanJsonFile();
   await promiseDirectoryDownloadOnPrefChange(kSourceUrlPref, exampleUrl + " ");
@@ -296,103 +296,103 @@ add_task(async function test_DirectoryLi
 add_task(async function test_DirectoryLinksProvider_getLinks_noDirectoryData() {
   let data = {
     "directory": [],
   };
   let dataURI = "data:application/json," + JSON.stringify(data);
   await promiseSetupDirectoryLinksProvider({linksURL: dataURI});
 
   let links = await fetchData();
-  do_check_eq(links.length, 0);
+  Assert.equal(links.length, 0);
   await promiseCleanDirectoryLinksProvider();
 });
 
 add_task(async function test_DirectoryLinksProvider_getLinks_badData() {
   let data = {
     "en-US": {
       "en-US": [{url: "http://example.com", title: "US"}],
     },
   };
   let dataURI = "data:application/json," + JSON.stringify(data);
   await promiseSetupDirectoryLinksProvider({linksURL: dataURI});
 
   // Make sure we get nothing for incorrectly formatted data
   let links = await fetchData();
-  do_check_eq(links.length, 0);
+  Assert.equal(links.length, 0);
   await promiseCleanDirectoryLinksProvider();
 });
 
 add_task(function test_DirectoryLinksProvider_needsDownload() {
   // test timestamping
   DirectoryLinksProvider._lastDownloadMS = 0;
-  do_check_true(DirectoryLinksProvider._needsDownload);
+  Assert.ok(DirectoryLinksProvider._needsDownload);
   DirectoryLinksProvider._lastDownloadMS = Date.now();
-  do_check_false(DirectoryLinksProvider._needsDownload);
+  Assert.ok(!DirectoryLinksProvider._needsDownload);
   DirectoryLinksProvider._lastDownloadMS = Date.now() - (60 * 60 * 24 + 1) * 1000;
-  do_check_true(DirectoryLinksProvider._needsDownload);
+  Assert.ok(DirectoryLinksProvider._needsDownload);
   DirectoryLinksProvider._lastDownloadMS = 0;
 });
 
 add_task(async function test_DirectoryLinksProvider_fetchAndCacheLinksIfNecessary() {
   await DirectoryLinksProvider.init();
   await cleanJsonFile();
   // explicitly change source url to cause the download during setup
   await promiseSetupDirectoryLinksProvider({linksURL: kTestURL + " "});
   await DirectoryLinksProvider._fetchAndCacheLinksIfNecessary();
 
   // inspect lastDownloadMS timestamp which should be 5 seconds less then now()
   let lastDownloadMS = DirectoryLinksProvider._lastDownloadMS;
-  do_check_true((Date.now() - lastDownloadMS) < 5000);
+  Assert.ok((Date.now() - lastDownloadMS) < 5000);
 
   // we should have fetched a new file during setup
   let data = await readJsonFile();
   isIdentical(data, kURLData);
 
   // attempt to download again - the timestamp should not change
   await DirectoryLinksProvider._fetchAndCacheLinksIfNecessary();
-  do_check_eq(DirectoryLinksProvider._lastDownloadMS, lastDownloadMS);
+  Assert.equal(DirectoryLinksProvider._lastDownloadMS, lastDownloadMS);
 
   // clean the file and force the download
   await cleanJsonFile();
   await DirectoryLinksProvider._fetchAndCacheLinksIfNecessary(true);
   data = await readJsonFile();
   isIdentical(data, kURLData);
 
   // make sure that failed download does not corrupt the file, nor changes lastDownloadMS
   lastDownloadMS = DirectoryLinksProvider._lastDownloadMS;
   await promiseDirectoryDownloadOnPrefChange(kSourceUrlPref, "http://");
   await DirectoryLinksProvider._fetchAndCacheLinksIfNecessary(true);
   data = await readJsonFile();
   isIdentical(data, kURLData);
-  do_check_eq(DirectoryLinksProvider._lastDownloadMS, lastDownloadMS);
+  Assert.equal(DirectoryLinksProvider._lastDownloadMS, lastDownloadMS);
 
   // _fetchAndCacheLinksIfNecessary must return same promise if download is in progress
   let downloadPromise = DirectoryLinksProvider._fetchAndCacheLinksIfNecessary(true);
   let anotherPromise = DirectoryLinksProvider._fetchAndCacheLinksIfNecessary(true);
-  do_check_true(downloadPromise === anotherPromise);
+  Assert.ok(downloadPromise === anotherPromise);
   await downloadPromise;
 
   await promiseCleanDirectoryLinksProvider();
 });
 
 add_task(async function test_DirectoryLinksProvider_fetchDirectoryOnPrefChange() {
   await DirectoryLinksProvider.init();
 
   let testObserver = new LinksChangeObserver();
   DirectoryLinksProvider.addObserver(testObserver);
 
   await cleanJsonFile();
   // ensure that provider does not think it needs to download
-  do_check_false(DirectoryLinksProvider._needsDownload);
+  Assert.ok(!DirectoryLinksProvider._needsDownload);
 
   // change the source URL, which should force directory download
   await promiseDirectoryDownloadOnPrefChange(kSourceUrlPref, kExampleURL);
   // then wait for testObserver to fire and test that json is downloaded
   await testObserver.deferred.promise;
-  do_check_eq(gLastRequestPath, kExamplePath);
+  Assert.equal(gLastRequestPath, kExamplePath);
   let data = await readJsonFile();
   isIdentical(data, kHttpHandlerData[kExamplePath]);
 
   await promiseCleanDirectoryLinksProvider();
 });
 
 add_task(async function test_DirectoryLinksProvider_fetchDirectoryOnInit() {
   // ensure preferences are set to defaults
@@ -429,42 +429,42 @@ add_task(async function test_DirectoryLi
     {url: "httpJUNKjavascript:42"},
     {url: "data:text/plain,hi"},
     {url: "http/bork:eh"},
   ]};
   let dataURI = "data:application/json," + JSON.stringify(data);
   await promiseSetupDirectoryLinksProvider({linksURL: dataURI});
 
   let links = await fetchData();
-  do_check_eq(links.length, 2);
+  Assert.equal(links.length, 2);
 
   // The only remaining url should be http and https
-  do_check_eq(links[0].url, data.directory[1].url);
-  do_check_eq(links[1].url, data.directory[3].url);
+  Assert.equal(links[0].url, data.directory[1].url);
+  Assert.equal(links[1].url, data.directory[3].url);
 });
 
 add_task(async function test_DirectoryLinksProvider_getAllowedImages() {
   let data = {"directory": [
     {url: "http://example.com", imageURI: "ftp://example.com"},
     {url: "http://example.com", imageURI: "http://example.net"},
     {url: "http://example.com", imageURI: "javascript:5"},
     {url: "http://example.com", imageURI: "https://example.com"},
     {url: "http://example.com", imageURI: "httpJUNKjavascript:42"},
     {url: "http://example.com", imageURI: "data:text/plain,hi"},
     {url: "http://example.com", imageURI: "http/bork:eh"},
   ]};
   let dataURI = "data:application/json," + JSON.stringify(data);
   await promiseSetupDirectoryLinksProvider({linksURL: dataURI});
 
   let links = await fetchData();
-  do_check_eq(links.length, 2);
+  Assert.equal(links.length, 2);
 
   // The only remaining images should be https and data
-  do_check_eq(links[0].imageURI, data.directory[3].imageURI);
-  do_check_eq(links[1].imageURI, data.directory[5].imageURI);
+  Assert.equal(links[0].imageURI, data.directory[3].imageURI);
+  Assert.equal(links[1].imageURI, data.directory[5].imageURI);
 });
 
 add_task(async function test_DirectoryLinksProvider_getAllowedImages_base() {
   let data = {"directory": [
     {url: "http://example1.com", imageURI: "https://example.com"},
     {url: "http://example2.com", imageURI: "https://tiles.cdn.mozilla.net"},
     {url: "http://example3.com", imageURI: "https://tiles2.cdn.mozilla.net"},
     {url: "http://example4.com", enhancedImageURI: "https://mozilla.net"},
@@ -472,50 +472,50 @@ add_task(async function test_DirectoryLi
   ]};
   let dataURI = "data:application/json," + JSON.stringify(data);
   await promiseSetupDirectoryLinksProvider({linksURL: dataURI});
 
   // Pretend we're using the default pref to trigger base matching
   DirectoryLinksProvider.__linksURLModified = false;
 
   let links = await fetchData();
-  do_check_eq(links.length, 4);
+  Assert.equal(links.length, 4);
 
   // The only remaining images should be https with mozilla.net or data URI
-  do_check_eq(links[0].url, data.directory[1].url);
-  do_check_eq(links[1].url, data.directory[2].url);
-  do_check_eq(links[2].url, data.directory[3].url);
-  do_check_eq(links[3].url, data.directory[4].url);
+  Assert.equal(links[0].url, data.directory[1].url);
+  Assert.equal(links[1].url, data.directory[2].url);
+  Assert.equal(links[2].url, data.directory[3].url);
+  Assert.equal(links[3].url, data.directory[4].url);
 });
 
 add_task(async function test_DirectoryLinksProvider_getAllowedEnhancedImages() {
   let data = {"directory": [
     {url: "http://example.com", enhancedImageURI: "ftp://example.com"},
     {url: "http://example.com", enhancedImageURI: "http://example.net"},
     {url: "http://example.com", enhancedImageURI: "javascript:5"},
     {url: "http://example.com", enhancedImageURI: "https://example.com"},
     {url: "http://example.com", enhancedImageURI: "httpJUNKjavascript:42"},
     {url: "http://example.com", enhancedImageURI: "data:text/plain,hi"},
     {url: "http://example.com", enhancedImageURI: "http/bork:eh"},
   ]};
   let dataURI = "data:application/json," + JSON.stringify(data);
   await promiseSetupDirectoryLinksProvider({linksURL: dataURI});
 
   let links = await fetchData();
-  do_check_eq(links.length, 2);
+  Assert.equal(links.length, 2);
 
   // The only remaining enhancedImages should be http and https and data
-  do_check_eq(links[0].enhancedImageURI, data.directory[3].enhancedImageURI);
-  do_check_eq(links[1].enhancedImageURI, data.directory[5].enhancedImageURI);
+  Assert.equal(links[0].enhancedImageURI, data.directory[3].enhancedImageURI);
+  Assert.equal(links[1].enhancedImageURI, data.directory[5].enhancedImageURI);
 });
 
 add_task(function test_DirectoryLinksProvider_setDefaultEnhanced() {
   function checkDefault(expected) {
     Services.prefs.clearUserPref(kNewtabEnhancedPref);
-    do_check_eq(Services.prefs.getBoolPref(kNewtabEnhancedPref), expected);
+    Assert.equal(Services.prefs.getBoolPref(kNewtabEnhancedPref), expected);
   }
 
   // Use the default donottrack prefs (enabled = false)
   Services.prefs.clearUserPref("privacy.donottrackheader.enabled");
   checkDefault(true);
 
   // Turn on DNT - no track
   Services.prefs.setBoolPref("privacy.donottrackheader.enabled", true);
@@ -525,10 +525,10 @@ add_task(function test_DirectoryLinksPro
   Services.prefs.clearUserPref("privacy.donottrackheader.enabled");
   checkDefault(true);
 
   // Clean up
   Services.prefs.clearUserPref("privacy.donottrackheader.value");
 });
 
 add_task(function test_DirectoryLinksProvider_anonymous() {
-  do_check_true(DirectoryLinksProvider._newXHR().mozAnon);
+  Assert.ok(DirectoryLinksProvider._newXHR().mozAnon);
 });
--- a/caps/tests/unit/test_origin.js
+++ b/caps/tests/unit/test_origin.js
@@ -4,161 +4,161 @@ var Cu = Components.utils;
 
 Cu.import("resource://gre/modules/Services.jsm");
 var ssm = Services.scriptSecurityManager;
 function makeURI(uri) { return Services.io.newURI(uri); }
 
 function checkThrows(f) {
   var threw = false;
   try { f(); } catch (e) { threw = true; }
-  do_check_true(threw);
+  Assert.ok(threw);
 }
 
 function checkCrossOrigin(a, b) {
-  do_check_false(a.equals(b));
-  do_check_false(a.equalsConsideringDomain(b));
-  do_check_false(a.subsumes(b));
-  do_check_false(a.subsumesConsideringDomain(b));
-  do_check_false(b.subsumes(a));
-  do_check_false(b.subsumesConsideringDomain(a));
+  Assert.ok(!a.equals(b));
+  Assert.ok(!a.equalsConsideringDomain(b));
+  Assert.ok(!a.subsumes(b));
+  Assert.ok(!a.subsumesConsideringDomain(b));
+  Assert.ok(!b.subsumes(a));
+  Assert.ok(!b.subsumesConsideringDomain(a));
 }
 
 function checkOriginAttributes(prin, attrs, suffix) {
   attrs = attrs || {};
-  do_check_eq(prin.originAttributes.appId, attrs.appId || 0);
-  do_check_eq(prin.originAttributes.inIsolatedMozBrowser, attrs.inIsolatedMozBrowser || false);
-  do_check_eq(prin.originSuffix, suffix || "");
-  do_check_eq(ChromeUtils.originAttributesToSuffix(attrs), suffix || "");
-  do_check_true(ChromeUtils.originAttributesMatchPattern(prin.originAttributes, attrs));
+  Assert.equal(prin.originAttributes.appId, attrs.appId || 0);
+  Assert.equal(prin.originAttributes.inIsolatedMozBrowser, attrs.inIsolatedMozBrowser || false);
+  Assert.equal(prin.originSuffix, suffix || "");
+  Assert.equal(ChromeUtils.originAttributesToSuffix(attrs), suffix || "");
+  Assert.ok(ChromeUtils.originAttributesMatchPattern(prin.originAttributes, attrs));
   if (!prin.isNullPrincipal && !prin.origin.startsWith("[")) {
-    do_check_true(ssm.createCodebasePrincipalFromOrigin(prin.origin).equals(prin));
+    Assert.ok(ssm.createCodebasePrincipalFromOrigin(prin.origin).equals(prin));
   } else {
     checkThrows(() => ssm.createCodebasePrincipalFromOrigin(prin.origin));
   }
 }
 
 function checkSandboxOriginAttributes(arr, attrs, options) {
   options = options || {};
   var sandbox = Cu.Sandbox(arr, options);
   checkOriginAttributes(Cu.getObjectPrincipal(sandbox), attrs,
                         ChromeUtils.originAttributesToSuffix(attrs));
 }
 
 // utility function useful for debugging
 function printAttrs(name, attrs) {
-  do_print(name + " {\n" +
-           "\tappId: " + attrs.appId + ",\n" +
-           "\tuserContextId: " + attrs.userContextId + ",\n" +
-           "\tinIsolatedMozBrowser: " + attrs.inIsolatedMozBrowser + ",\n" +
-           "\tprivateBrowsingId: '" + attrs.privateBrowsingId + "',\n" +
-           "\tfirstPartyDomain: '" + attrs.firstPartyDomain + "'\n}");
+  info(name + " {\n" +
+       "\tappId: " + attrs.appId + ",\n" +
+       "\tuserContextId: " + attrs.userContextId + ",\n" +
+       "\tinIsolatedMozBrowser: " + attrs.inIsolatedMozBrowser + ",\n" +
+       "\tprivateBrowsingId: '" + attrs.privateBrowsingId + "',\n" +
+       "\tfirstPartyDomain: '" + attrs.firstPartyDomain + "'\n}");
 }
 
 
 function checkValues(attrs, values) {
   values = values || {};
   // printAttrs("attrs", attrs);
   // printAttrs("values", values);
-  do_check_eq(attrs.appId, values.appId || 0);
-  do_check_eq(attrs.userContextId, values.userContextId || 0);
-  do_check_eq(attrs.inIsolatedMozBrowser, values.inIsolatedMozBrowser || false);
-  do_check_eq(attrs.privateBrowsingId, values.privateBrowsingId || "");
-  do_check_eq(attrs.firstPartyDomain, values.firstPartyDomain || "");
+  Assert.equal(attrs.appId, values.appId || 0);
+  Assert.equal(attrs.userContextId, values.userContextId || 0);
+  Assert.equal(attrs.inIsolatedMozBrowser, values.inIsolatedMozBrowser || false);
+  Assert.equal(attrs.privateBrowsingId, values.privateBrowsingId || "");
+  Assert.equal(attrs.firstPartyDomain, values.firstPartyDomain || "");
 }
 
 function run_test() {
   // Attributeless origins.
-  do_check_eq(ssm.getSystemPrincipal().origin, "[System Principal]");
+  Assert.equal(ssm.getSystemPrincipal().origin, "[System Principal]");
   checkOriginAttributes(ssm.getSystemPrincipal());
   var exampleOrg = ssm.createCodebasePrincipal(makeURI("http://example.org"), {});
-  do_check_eq(exampleOrg.origin, "http://example.org");
+  Assert.equal(exampleOrg.origin, "http://example.org");
   checkOriginAttributes(exampleOrg);
   var exampleCom = ssm.createCodebasePrincipal(makeURI("https://www.example.com:123"), {});
-  do_check_eq(exampleCom.origin, "https://www.example.com:123");
+  Assert.equal(exampleCom.origin, "https://www.example.com:123");
   checkOriginAttributes(exampleCom);
   var nullPrin = Cu.getObjectPrincipal(new Cu.Sandbox(null));
-  do_check_true(/^moz-nullprincipal:\{([0-9]|[a-z]|\-){36}\}$/.test(nullPrin.origin));
+  Assert.ok(/^moz-nullprincipal:\{([0-9]|[a-z]|\-){36}\}$/.test(nullPrin.origin));
   checkOriginAttributes(nullPrin);
   var ipv6Prin = ssm.createCodebasePrincipal(makeURI("https://[2001:db8::ff00:42:8329]:123"), {});
-  do_check_eq(ipv6Prin.origin, "https://[2001:db8::ff00:42:8329]:123");
+  Assert.equal(ipv6Prin.origin, "https://[2001:db8::ff00:42:8329]:123");
   checkOriginAttributes(ipv6Prin);
   var ipv6NPPrin = ssm.createCodebasePrincipal(makeURI("https://[2001:db8::ff00:42:8329]"), {});
-  do_check_eq(ipv6NPPrin.origin, "https://[2001:db8::ff00:42:8329]");
+  Assert.equal(ipv6NPPrin.origin, "https://[2001:db8::ff00:42:8329]");
   checkOriginAttributes(ipv6NPPrin);
   var ep = Cu.getObjectPrincipal(Cu.Sandbox([exampleCom, nullPrin, exampleOrg]));
   checkOriginAttributes(ep);
   checkCrossOrigin(exampleCom, exampleOrg);
   checkCrossOrigin(exampleOrg, nullPrin);
 
   // nsEP origins should be in lexical order.
-  do_check_eq(ep.origin, `[Expanded Principal [${exampleOrg.origin}, ${exampleCom.origin}, ${nullPrin.origin}]]`);
+  Assert.equal(ep.origin, `[Expanded Principal [${exampleOrg.origin}, ${exampleCom.origin}, ${nullPrin.origin}]]`);
 
   // Make sure createCodebasePrincipal does what the rest of gecko does.
-  do_check_true(exampleOrg.equals(Cu.getObjectPrincipal(new Cu.Sandbox("http://example.org"))));
+  Assert.ok(exampleOrg.equals(Cu.getObjectPrincipal(new Cu.Sandbox("http://example.org"))));
 
   //
   // Test origin attributes.
   //
 
   // Just app.
   var exampleOrg_app = ssm.createCodebasePrincipal(makeURI("http://example.org"), {appId: 42});
   var nullPrin_app = ssm.createNullPrincipal({appId: 42});
   checkOriginAttributes(exampleOrg_app, {appId: 42}, "^appId=42");
   checkOriginAttributes(nullPrin_app, {appId: 42}, "^appId=42");
-  do_check_eq(exampleOrg_app.origin, "http://example.org^appId=42");
+  Assert.equal(exampleOrg_app.origin, "http://example.org^appId=42");
 
   // Just browser.
   var exampleOrg_browser = ssm.createCodebasePrincipal(makeURI("http://example.org"), {inIsolatedMozBrowser: true});
   var nullPrin_browser = ssm.createNullPrincipal({inIsolatedMozBrowser: true});
   checkOriginAttributes(exampleOrg_browser, {inIsolatedMozBrowser: true}, "^inBrowser=1");
   checkOriginAttributes(nullPrin_browser, {inIsolatedMozBrowser: true}, "^inBrowser=1");
-  do_check_eq(exampleOrg_browser.origin, "http://example.org^inBrowser=1");
+  Assert.equal(exampleOrg_browser.origin, "http://example.org^inBrowser=1");
 
   // App and browser.
   var exampleOrg_appBrowser = ssm.createCodebasePrincipal(makeURI("http://example.org"), {inIsolatedMozBrowser: true, appId: 42});
   var nullPrin_appBrowser = ssm.createNullPrincipal({inIsolatedMozBrowser: true, appId: 42});
   checkOriginAttributes(exampleOrg_appBrowser, {appId: 42, inIsolatedMozBrowser: true}, "^appId=42&inBrowser=1");
   checkOriginAttributes(nullPrin_appBrowser, {appId: 42, inIsolatedMozBrowser: true}, "^appId=42&inBrowser=1");
-  do_check_eq(exampleOrg_appBrowser.origin, "http://example.org^appId=42&inBrowser=1");
+  Assert.equal(exampleOrg_appBrowser.origin, "http://example.org^appId=42&inBrowser=1");
 
   // App and browser, different domain.
   var exampleCom_appBrowser = ssm.createCodebasePrincipal(makeURI("https://www.example.com:123"), {appId: 42, inIsolatedMozBrowser: true});
   checkOriginAttributes(exampleCom_appBrowser, {appId: 42, inIsolatedMozBrowser: true}, "^appId=42&inBrowser=1");
-  do_check_eq(exampleCom_appBrowser.origin, "https://www.example.com:123^appId=42&inBrowser=1");
+  Assert.equal(exampleCom_appBrowser.origin, "https://www.example.com:123^appId=42&inBrowser=1");
 
   // First party Uri
   var exampleOrg_firstPartyDomain = ssm.createCodebasePrincipal(makeURI("http://example.org"), {firstPartyDomain: "example.org"});
   checkOriginAttributes(exampleOrg_firstPartyDomain, { firstPartyDomain: "example.org" }, "^firstPartyDomain=example.org");
-  do_check_eq(exampleOrg_firstPartyDomain.origin, "http://example.org^firstPartyDomain=example.org");
+  Assert.equal(exampleOrg_firstPartyDomain.origin, "http://example.org^firstPartyDomain=example.org");
 
   // Make sure we don't crash when serializing principals with UNKNOWN_APP_ID.
   try {
     let binaryStream = Cc["@mozilla.org/binaryoutputstream;1"].
                        createInstance(Ci.nsIObjectOutputStream);
     let pipe = Cc["@mozilla.org/pipe;1"].createInstance(Ci.nsIPipe);
     pipe.init(false, false, 0, 0xffffffff, null);
     binaryStream.setOutputStream(pipe.outputStream);
     binaryStream.writeCompoundObject(simplePrin, Ci.nsISupports, true); // eslint-disable-line no-undef
     binaryStream.close();
   } catch (e) {
-    do_check_true(true);
+    Assert.ok(true);
   }
 
 
   // Just userContext.
   var exampleOrg_userContext = ssm.createCodebasePrincipal(makeURI("http://example.org"), {userContextId: 42});
   checkOriginAttributes(exampleOrg_userContext, { userContextId: 42 }, "^userContextId=42");
-  do_check_eq(exampleOrg_userContext.origin, "http://example.org^userContextId=42");
+  Assert.equal(exampleOrg_userContext.origin, "http://example.org^userContextId=42");
 
   // UserContext and App.
   var exampleOrg_userContextApp = ssm.createCodebasePrincipal(makeURI("http://example.org"), {appId: 24, userContextId: 42});
   var nullPrin_userContextApp = ssm.createNullPrincipal({appId: 24, userContextId: 42});
   checkOriginAttributes(exampleOrg_userContextApp, {appId: 24, userContextId: 42}, "^appId=24&userContextId=42");
   checkOriginAttributes(nullPrin_userContextApp, {appId: 24, userContextId: 42}, "^appId=24&userContextId=42");
-  do_check_eq(exampleOrg_userContextApp.origin, "http://example.org^appId=24&userContextId=42");
+  Assert.equal(exampleOrg_userContextApp.origin, "http://example.org^appId=24&userContextId=42");
 
   checkSandboxOriginAttributes(null, {});
   checkSandboxOriginAttributes("http://example.org", {});
   checkSandboxOriginAttributes("http://example.org", {}, {originAttributes: {}});
   checkSandboxOriginAttributes("http://example.org", {appId: 42}, {originAttributes: {appId: 42}});
   checkSandboxOriginAttributes(["http://example.org"], {});
   checkSandboxOriginAttributes(["http://example.org"], {}, {originAttributes: {}});
   checkSandboxOriginAttributes(["http://example.org"], {appId: 42}, {originAttributes: {appId: 42}});
@@ -172,20 +172,20 @@ function run_test() {
   checkCrossOrigin(exampleOrg_appBrowser, nullPrin_appBrowser);
   checkCrossOrigin(exampleOrg_appBrowser, exampleCom_appBrowser);
   checkCrossOrigin(exampleOrg_firstPartyDomain, exampleOrg);
   checkCrossOrigin(exampleOrg_userContext, exampleOrg);
   checkCrossOrigin(exampleOrg_userContext, exampleOrg_userContextApp);
 
   // Check Principal kinds.
   function checkKind(prin, kind) {
-    do_check_eq(prin.isNullPrincipal, kind == "nullPrincipal");
-    do_check_eq(prin.isCodebasePrincipal, kind == "codebasePrincipal");
-    do_check_eq(prin.isExpandedPrincipal, kind == "expandedPrincipal");
-    do_check_eq(prin.isSystemPrincipal, kind == "systemPrincipal");
+    Assert.equal(prin.isNullPrincipal, kind == "nullPrincipal");
+    Assert.equal(prin.isCodebasePrincipal, kind == "codebasePrincipal");
+    Assert.equal(prin.isExpandedPrincipal, kind == "expandedPrincipal");
+    Assert.equal(prin.isSystemPrincipal, kind == "systemPrincipal");
   }
   checkKind(ssm.createNullPrincipal({}), "nullPrincipal");
   checkKind(ssm.createCodebasePrincipal(makeURI("http://www.example.com"), {}), "codebasePrincipal");
   checkKind(Cu.getObjectPrincipal(Cu.Sandbox([ssm.createCodebasePrincipal(makeURI("http://www.example.com"), {})])), "expandedPrincipal");
   checkKind(ssm.getSystemPrincipal(), "systemPrincipal");
 
   //
   // Test Origin Attribute Manipulation
@@ -205,24 +205,24 @@ function run_test() {
     [ "^firstPartyDomain=example.org", {firstPartyDomain: "example.org"} ],
     [ "^appId=3&inBrowser=1&userContextId=6",
       {appId: 3, userContextId: 6, inIsolatedMozBrowser: true} ] ];
 
   // check that we can create an origin attributes from an origin properly
   tests.forEach(t => {
     let attrs = ChromeUtils.createOriginAttributesFromOrigin(uri + t[0]);
     checkValues(attrs, t[1]);
-    do_check_eq(ChromeUtils.originAttributesToSuffix(attrs), t[0]);
+    Assert.equal(ChromeUtils.originAttributesToSuffix(attrs), t[0]);
   });
 
   // check that we can create an origin attributes from a dict properly
   tests.forEach(t => {
     let attrs = ChromeUtils.fillNonDefaultOriginAttributes(t[1]);
     checkValues(attrs, t[1]);
-    do_check_eq(ChromeUtils.originAttributesToSuffix(attrs), t[0]);
+    Assert.equal(ChromeUtils.originAttributesToSuffix(attrs), t[0]);
   });
 
   // each row in the set_tests array has these values:
   // [0] - the suffix used to create an origin attribute from
   // [1] - the expected result of creating an origin attribute from [0]
   // [2] - the pattern to set on the origin attributes
   // [3] - the expected result of setting [2] values on [1]
   // [4] - the expected result of creating a suffix from [3]
@@ -236,17 +236,17 @@ function run_test() {
   set_tests.forEach(t => {
     let orig = ChromeUtils.createOriginAttributesFromOrigin(uri + t[0]);
     checkValues(orig, t[1]);
     let mod = orig;
     for (var key in t[2]) {
       mod[key] = t[2][key];
     }
     checkValues(mod, t[3]);
-    do_check_eq(ChromeUtils.originAttributesToSuffix(mod), t[4]);
+    Assert.equal(ChromeUtils.originAttributesToSuffix(mod), t[4]);
   });
 
   // each row in the dflt_tests array has these values:
   // [0] - the suffix used to create an origin attribute from
   // [1] - the expected result of creating an origin attributes from [0]
   // [2] - the expected result after setting userContextId to the default
   // [3] - the expected result of creating a suffix from [2]
   var dflt_tests = [
@@ -257,17 +257,17 @@ function run_test() {
 
   // check that we can set the userContextId to default properly
   dflt_tests.forEach(t => {
     let orig = ChromeUtils.createOriginAttributesFromOrigin(uri + t[0]);
     checkValues(orig, t[1]);
     let mod = orig;
     mod.userContextId = 0;
     checkValues(mod, t[2]);
-    do_check_eq(ChromeUtils.originAttributesToSuffix(mod), t[3]);
+    Assert.equal(ChromeUtils.originAttributesToSuffix(mod), t[3]);
   });
 
   // each row in the dflt2_tests array has these values:
   // [0] - the suffix used to create an origin attribute from
   // [1] - the expected result of creating an origin attributes from [0]
   // [2] - the expected result after setting firstPartyUri to the default
   // [3] - the expected result of creating a suffix from [2]
   var dflt2_tests = [
@@ -278,27 +278,27 @@ function run_test() {
 
   // check that we can set the userContextId to default properly
   dflt2_tests.forEach(t => {
     let orig = ChromeUtils.createOriginAttributesFromOrigin(uri + t[0]);
     checkValues(orig, t[1]);
     let mod = orig;
     mod.firstPartyDomain = "";
     checkValues(mod, t[2]);
-    do_check_eq(ChromeUtils.originAttributesToSuffix(mod), t[3]);
+    Assert.equal(ChromeUtils.originAttributesToSuffix(mod), t[3]);
   });
 
   var fileURI = makeURI("file:///foo/bar").QueryInterface(Ci.nsIFileURL);
   var fileTests = [
     [true, fileURI.spec],
     [false, "file://UNIVERSAL_FILE_URI_ORIGIN"],
   ];
   fileTests.forEach(t => {
     Services.prefs.setBoolPref("security.fileuri.strict_origin_policy", t[0]);
     var filePrin = ssm.createCodebasePrincipal(fileURI, {});
-    do_check_eq(filePrin.origin, t[1]);
+    Assert.equal(filePrin.origin, t[1]);
   });
   Services.prefs.clearUserPref("security.fileuri.strict_origin_policy");
 
   var aboutBlankURI = makeURI("about:blank");
   var aboutBlankPrin = ssm.createCodebasePrincipal(aboutBlankURI, {});
-  do_check_true(/^moz-nullprincipal:\{([0-9]|[a-z]|\-){36}\}$/.test(aboutBlankPrin.origin));
+  Assert.ok(/^moz-nullprincipal:\{([0-9]|[a-z]|\-){36}\}$/.test(aboutBlankPrin.origin));
 }
--- a/chrome/test/unit/test_abi.js
+++ b/chrome/test/unit/test_abi.js
@@ -16,13 +16,13 @@ function is_registered(name) {
     var d = catman.getCategoryEntry("abitest", name);
     return d == "found";
   } catch (e) {
     return false;
   }
 }
 
 function run_test() {
-  do_check_true(is_registered("test1"));
-  do_check_false(is_registered("test2"));
-  do_check_true(is_registered("test3"));
-  do_check_false(is_registered("test4"));
+  Assert.ok(is_registered("test1"));
+  Assert.ok(!is_registered("test2"));
+  Assert.ok(is_registered("test3"));
+  Assert.ok(!is_registered("test4"));
 }
--- a/chrome/test/unit/test_bug292789.js
+++ b/chrome/test/unit/test_bug292789.js
@@ -9,17 +9,17 @@ const MANIFESTS = [
 
 registerManifests(MANIFESTS);
 
 var gCR;
 
 function check_accessibility(spec, desired) {
   var uri = Services.io.newURI(spec);
   var actual = gCR.allowContentToAccess(uri);
-  do_check_eq(desired, actual);
+  Assert.equal(desired, actual);
 }
 
 function run_test() {
   gCR = Cc["@mozilla.org/chrome/chrome-registry;1"].
     getService(Ci.nsIXULChromeRegistry);
   gCR.checkForNewChrome();
 
   check_accessibility("chrome://test1/content/", false);
--- a/chrome/test/unit/test_bug380398.js
+++ b/chrome/test/unit/test_bug380398.js
@@ -24,17 +24,17 @@ chromeReg.checkForNewChrome();
 
 var target = Services.io.newFileURI(do_get_file("data"));
 target = target.spec + "test/test.xul";
 
 function test_succeeded_mapping(namespace) {
   var uri = Services.io.newURI("chrome://" + namespace + "/content/test.xul");
   try {
     var result = chromeReg.convertChromeURL(uri);
-    do_check_eq(result.spec, target);
+    Assert.equal(result.spec, target);
   } catch (ex) {
     do_throw(namespace);
   }
 }
 
 function test_failed_mapping(namespace) {
   var uri = Services.io.newURI("chrome://" + namespace + "/content/test.xul");
   try {
--- a/chrome/test/unit/test_bug397073.js
+++ b/chrome/test/unit/test_bug397073.js
@@ -24,17 +24,17 @@ chromeReg.checkForNewChrome();
 
 var target = Services.io.newFileURI(do_get_file("data"));
 target = target.spec + "test/test.xul";
 
 function test_succeeded_mapping(namespace) {
   var uri = Services.io.newURI("chrome://" + namespace + "/content/test.xul");
   try {
     var result = chromeReg.convertChromeURL(uri);
-    do_check_eq(result.spec, target);
+    Assert.equal(result.spec, target);
   } catch (ex) {
     do_throw(namespace);
   }
 }
 
 function test_failed_mapping(namespace) {
   var uri = Services.io.newURI("chrome://" + namespace + "/content/test.xul");
   try {
--- a/chrome/test/unit/test_bug399707.js
+++ b/chrome/test/unit/test_bug399707.js
@@ -23,17 +23,17 @@ chromeReg.checkForNewChrome();
 
 var target = Services.io.newFileURI(do_get_file("data"));
 target = target.spec + "test/test.xul";
 
 function test_succeeded_mapping(namespace) {
   var uri = Services.io.newURI("chrome://" + namespace + "/content/test.xul");
   try {
     var result = chromeReg.convertChromeURL(uri);
-    do_check_eq(result.spec, target);
+    Assert.equal(result.spec, target);
   } catch (ex) {
     do_throw(namespace);
   }
 }
 
 function test_failed_mapping(namespace) {
   var uri = Services.io.newURI("chrome://" + namespace + "/content/test.xul");
   try {
--- a/chrome/test/unit/test_bug401153.js
+++ b/chrome/test/unit/test_bug401153.js
@@ -21,28 +21,28 @@ var chromeReg = Cc["@mozilla.org/chrome/
                  .getService(Ci.nsIChromeRegistry);
 chromeReg.checkForNewChrome();
 
 var rph = Services.io.getProtocolHandler("resource")
               .QueryInterface(Ci.nsIResProtocolHandler);
 
 function test_succeeded_mapping(namespace, target) {
   try {
-    do_check_true(rph.hasSubstitution(namespace));
+    Assert.ok(rph.hasSubstitution(namespace));
     var uri = Services.io.newURI("resource://" + namespace);
     dump("### checking for " + target + ", getting " + rph.resolveURI(uri) + "\n");
-    do_check_eq(rph.resolveURI(uri), target);
+    Assert.equal(rph.resolveURI(uri), target);
   } catch (ex) {
     dump(ex + "\n");
     do_throw(namespace);
   }
 }
 
 function test_failed_mapping(namespace) {
-  do_check_false(rph.hasSubstitution(namespace));
+  Assert.ok(!rph.hasSubstitution(namespace));
 }
 
 function run_test() {
   var data = Services.io.newFileURI(do_get_file("data")).spec;
   test_succeeded_mapping("test1", data + "test1/");
   test_succeeded_mapping("test3", "jar:" + data + "test3.jar!/resources/");
   test_failed_mapping("test4");
   test_succeeded_mapping("test5", data + "test5/");
--- a/chrome/test/unit/test_bug415367.js
+++ b/chrome/test/unit/test_bug415367.js
@@ -17,18 +17,18 @@ function test_uri(obj) {
     if (obj.result) {
       failed = true;
       message = obj.uri + " should be accepted as a valid URI";
     }
   }
   if (failed)
     do_throw(message);
   if (obj.result) {
-    do_check_true(uri != null);
-    do_check_eq(uri.spec, obj.uri);
+    Assert.ok(uri != null);
+    Assert.equal(uri.spec, obj.uri);
   }
 }
 
 function run_test() {
   var tests = [
     {uri: "chrome://blah/content/blah.xul", result: true},
     {uri: "chrome://blah/content/:/blah/blah.xul", result: false},
     {uri: "chrome://blah/content/%252e./blah/blah.xul", result: false},
--- a/chrome/test/unit/test_bug564667.js
+++ b/chrome/test/unit/test_bug564667.js
@@ -13,17 +13,17 @@ var gCR = Cc["@mozilla.org/chrome/chrome
 /*
  * Checks that a mapping was added
  */
 function test_mapping(chromeURL, target) {
   var uri = Services.io.newURI(chromeURL);
 
   try {
     var result = gCR.convertChromeURL(uri);
-    do_check_eq(result.spec, target);
+    Assert.equal(result.spec, target);
   } catch (ex) {
     do_throw(chromeURL + " not Registered");
   }
 }
 
 /*
  * Checks that a mapping was removed
  */
--- a/chrome/test/unit/test_bug848297.js
+++ b/chrome/test/unit/test_bug848297.js
@@ -26,20 +26,20 @@ function enum_to_array(strings) {
   rv.sort();
   return rv;
 }
 
 function run_test() {
 
   // without override
   Services.locale.setRequestedLocales(["de"]);
-  do_check_eq(chromeReg.getSelectedLocale("basepack"), "en-US");
-  do_check_eq(chromeReg.getSelectedLocale("overpack"), "de");
-  do_check_matches(enum_to_array(chromeReg.getLocalesForPackage("basepack")),
+  Assert.equal(chromeReg.getSelectedLocale("basepack"), "en-US");
+  Assert.equal(chromeReg.getSelectedLocale("overpack"), "de");
+  Assert.deepEqual(enum_to_array(chromeReg.getLocalesForPackage("basepack")),
                    ["en-US", "fr"]);
 
   // with override
   Services.prefs.setCharPref("chrome.override_package.basepack", "overpack");
-  do_check_eq(chromeReg.getSelectedLocale("basepack"), "de");
-  do_check_matches(enum_to_array(chromeReg.getLocalesForPackage("basepack")),
+  Assert.equal(chromeReg.getSelectedLocale("basepack"), "de");
+  Assert.deepEqual(enum_to_array(chromeReg.getLocalesForPackage("basepack")),
                    ["de", "en-US"]);
 
 }
--- a/chrome/test/unit/test_crlf.js
+++ b/chrome/test/unit/test_crlf.js
@@ -3,10 +3,10 @@ registerManifests([do_get_file("data/tes
 function run_test() {
   let cr = Cc["@mozilla.org/chrome/chrome-registry;1"].
     getService(Ci.nsIChromeRegistry);
 
   let sourceURI = Services.io.newURI("chrome://test_crlf/content/");
   // this throws for packages that are not registered
   let file = cr.convertChromeURL(sourceURI).QueryInterface(Ci.nsIFileURL).file;
 
-  do_check_true(file.equals(do_get_file("data/test_crlf.xul", true)));
+  Assert.ok(file.equals(do_get_file("data/test_crlf.xul", true)));
 }
--- a/chrome/test/unit/test_data_protocol_registration.js
+++ b/chrome/test/unit/test_data_protocol_registration.js
@@ -77,17 +77,17 @@ function run_test() {
   // Check that our override worked
   let expectedURI = "data:application/vnd.mozilla.xul+xml,";
   let sourceURI = "chrome://good-package/content/test.xul";
   try {
     sourceURI = Services.io.newURI(sourceURI);
     // this throws for packages that are not registered
     let uri = cr.convertChromeURL(sourceURI).spec;
 
-    do_check_eq(expectedURI, uri);
+    Assert.equal(expectedURI, uri);
   } catch (e) {
     dump(e + "\n");
     do_throw("Should have registered our URI!");
   }
 
   // Unregister our factories so we do not leak
   for (let i = 0; i < factories.length; i++) {
     let factory = factories[i];
--- a/chrome/test/unit/test_no_remote_registration.js
+++ b/chrome/test/unit/test_no_remote_registration.js
@@ -187,21 +187,21 @@ function run_test() {
           // this throws for packages that are not registered
           uri = rph.resolveURI(sourceURI);
         } else {
           // this throws for packages that are not registered
           uri = cr.convertChromeURL(sourceURI).spec;
         }
 
         if (protocol.shouldRegister) {
-          do_check_eq(expectedURI, uri);
+          Assert.equal(expectedURI, uri);
         } else {
           // Overrides will not throw, so we'll get to here.  We want to make
           // sure that the two strings are not the same in this situation.
-          do_check_neq(expectedURI, uri);
+          Assert.notEqual(expectedURI, uri);
         }
       } catch (e) {
         if (protocol.shouldRegister) {
           dump(e + "\n");
           do_throw("Should have registered our URI for protocol " +
                    protocol.scheme);
         }
       }
--- a/chrome/test/unit/test_resolve_uris.js
+++ b/chrome/test/unit/test_resolve_uris.js
@@ -67,17 +67,17 @@ function do_run_test() {
         // resources go about a slightly different way than everything else
         let rph = Services.io.getProtocolHandler("resource").
             QueryInterface(Ci.nsIResProtocolHandler);
         uri = rph.resolveURI(sourceURI);
       } else {
         uri = cr.convertChromeURL(sourceURI).spec;
       }
 
-      do_check_eq(expectedURI, uri);
+      Assert.equal(expectedURI, uri);
     } catch (e) {
       dump(e + "\n");
       do_throw("Should have registered a handler for type '" +
                type + "'\n");
     }
   }
 }
 
--- a/devtools/client/animationinspector/test/unit/test_findOptimalTimeInterval.js
+++ b/devtools/client/animationinspector/test/unit/test_findOptimalTimeInterval.js
@@ -63,18 +63,18 @@ const TEST_DATA = [{
   expectedInterval: 2500
 }, {
   minTimeInterval: 9800,
   expectedInterval: 10000
 }];
 
 function run_test() {
   for (let {minTimeInterval, desc, expectedInterval} of TEST_DATA) {
-    do_print(`Testing minTimeInterval: ${minTimeInterval}.
-              Expecting ${expectedInterval}.`);
+    info(`Testing minTimeInterval: ${minTimeInterval}.
+          Expecting ${expectedInterval}.`);
 
     let interval = findOptimalTimeInterval(minTimeInterval);
     if (typeof expectedInterval == "string") {
       ok(eval(expectedInterval), desc);
     } else {
       equal(interval, expectedInterval, desc);
     }
   }
--- a/devtools/client/animationinspector/test/unit/test_timeScale.js
+++ b/devtools/client/animationinspector/test/unit/test_timeScale.js
@@ -129,79 +129,79 @@ const TEST_FORMAT_TIME_S = [{
   time: 102540,
   expectedFormattedTime: "102.5s"
 }, {
   time: 102940,
   expectedFormattedTime: "102.9s"
 }];
 
 function run_test() {
-  do_print("Check the default min/max range values");
+  info("Check the default min/max range values");
   equal(TimeScale.minStartTime, Infinity);
   equal(TimeScale.maxEndTime, 0);
 
   for (let {desc, animations, expectedMinStart, expectedMaxEnd} of
        TEST_ANIMATIONS) {
-    do_print("Test adding a few animations: " + desc);
+    info("Test adding a few animations: " + desc);
     for (let state of animations) {
       TimeScale.addAnimation(state);
     }
 
-    do_print("Checking the time scale range");
+    info("Checking the time scale range");
     equal(TimeScale.minStartTime, expectedMinStart);
     equal(TimeScale.maxEndTime, expectedMaxEnd);
 
-    do_print("Test reseting the animations");
+    info("Test reseting the animations");
     TimeScale.reset();
     equal(TimeScale.minStartTime, Infinity);
     equal(TimeScale.maxEndTime, 0);
   }
 
-  do_print("Add a set of animations again");
+  info("Add a set of animations again");
   for (let state of TEST_ANIMATIONS[0].animations) {
     TimeScale.addAnimation(state);
   }
 
-  do_print("Test converting start times to distances");
+  info("Test converting start times to distances");
   for (let {time, expectedDistance} of TEST_STARTTIME_TO_DISTANCE) {
     let distance = TimeScale.startTimeToDistance(time);
     equal(distance, expectedDistance);
   }
 
-  do_print("Test converting durations to distances");
+  info("Test converting durations to distances");
   for (let {time, expectedDistance} of TEST_DURATION_TO_DISTANCE) {
     let distance = TimeScale.durationToDistance(time);
     equal(distance, expectedDistance);
   }
 
-  do_print("Test converting distances to times");
+  info("Test converting distances to times");
   for (let {distance, expectedTime} of TEST_DISTANCE_TO_TIME) {
     let time = TimeScale.distanceToTime(distance);
     equal(time, expectedTime);
   }
 
-  do_print("Test converting distances to relative times");
+  info("Test converting distances to relative times");
   for (let {distance, expectedTime} of TEST_DISTANCE_TO_RELATIVE_TIME) {
     let time = TimeScale.distanceToRelativeTime(distance);
     equal(time, expectedTime);
   }
 
-  do_print("Test formatting times (millis)");
+  info("Test formatting times (millis)");
   for (let {time, expectedFormattedTime} of TEST_FORMAT_TIME_MS) {
     let formattedTime = TimeScale.formatTime(time);
     equal(formattedTime, expectedFormattedTime);
   }
 
   // Add 1 more animation to increase the range and test more time formatting
   // cases.
   TimeScale.addAnimation({
     startTime: 3000,
     duration: 5000,
     delay: 0,
     iterationCount: 1
   });
 
-  do_print("Test formatting times (seconds)");
+  info("Test formatting times (seconds)");
   for (let {time, expectedFormattedTime} of TEST_FORMAT_TIME_S) {
     let formattedTime = TimeScale.formatTime(time);
     equal(formattedTime, expectedFormattedTime);
   }
 }
--- a/devtools/client/animationinspector/test/unit/test_timeScale_dimensions.js
+++ b/devtools/client/animationinspector/test/unit/test_timeScale_dimensions.js
@@ -29,23 +29,23 @@ const TEST_ENDDELAY_X = [{
     iterationCount: 9,
     delay: 500,
     endDelay: -500
   }],
   expectedEndDelayX: 90
 }];
 
 function run_test() {
-  do_print("Test calculating endDelayX");
+  info("Test calculating endDelayX");
 
   // Be independent of possible prior tests
   TimeScale.reset();
 
   for (let {desc, animations, expectedEndDelayX} of TEST_ENDDELAY_X) {
-    do_print(`Adding animations: ${desc}`);
+    info(`Adding animations: ${desc}`);
 
     for (let state of animations) {
       TimeScale.addAnimation(state);
 
       let {endDelayX} = TimeScale.getAnimationDimensions({state});
       equal(endDelayX, expectedEndDelayX);
 
       TimeScale.reset();
--- a/devtools/client/framework/test/shared-redux-head.js
+++ b/devtools/client/framework/test/shared-redux-head.js
@@ -8,48 +8,33 @@
 /* eslint no-unused-vars: [2, {"vars": "local"}] */
 /* import-globals-from ./shared-head.js */
 // Currently this file expects "defer" to be imported into scope.
 
 // Common utility functions for working with Redux stores.  The file is meant
 // to be safe to load in both mochitest and xpcshell environments.
 
 /**
- * A logging function that can be used from xpcshell and browser mochitest
- * environments.
- */
-function commonLog(message) {
-  let log;
-  if (Services && Services.appinfo && Services.appinfo.name &&
-      Services.appinfo.name == "Firefox") {
-    log = info;
-  } else {
-    log = do_print;
-  }
-  log(message);
-}
-
-/**
  * Wait until the store has reached a state that matches the predicate.
  * @param Store store
  *        The Redux store being used.
  * @param function predicate
  *        A function that returns true when the store has reached the expected
  *        state.
  * @return Promise
  *         Resolved once the store reaches the expected state.
  */
 function waitUntilState(store, predicate) {
   let deferred = defer();
   let unsubscribe = store.subscribe(check);
 
-  commonLog(`Waiting for state predicate "${predicate}"`);
+  info(`Waiting for state predicate "${predicate}"`);
   function check() {
     if (predicate(store.getState())) {
-      commonLog(`Found state predicate "${predicate}"`);
+      info(`Found state predicate "${predicate}"`);
       unsubscribe();
       deferred.resolve();
     }
   }
 
   // Fire the check immediately in case the action has already occurred
   check();
 
@@ -66,20 +51,20 @@ function waitUntilState(store, predicate
  *         Resolved once the expected action is emitted by the store.
  */
 function waitUntilAction(store, actionType) {
   let deferred = defer();
   let unsubscribe = store.subscribe(check);
   let history = store.history;
   let index = history.length;
 
-  commonLog(`Waiting for action "${actionType}"`);
+  info(`Waiting for action "${actionType}"`);
   function check() {
     let action = history[index++];
     if (action && action.type === actionType) {
-      commonLog(`Found action "${actionType}"`);
+      info(`Found action "${actionType}"`);
       unsubscribe();
       deferred.resolve(store.getState());
     }
   }
 
   return deferred.promise;
 }
--- a/devtools/client/inspector/grids/test/unit/test_compare_fragments_geometry.js
+++ b/devtools/client/inspector/grids/test/unit/test_compare_fragments_geometry.js
@@ -67,13 +67,13 @@ const TESTS = [{
       rows: {lines: [{start: 0}, {start: 1000}, {start: 2000}]}}]
   ],
   expected: true
 }];
 
 function run_test() {
   for (let { desc, grids, expected } of TESTS) {
     if (desc) {
-      do_print(desc);
+      info(desc);
     }
     equal(compareFragmentsGeometry(grids[0], grids[1]), expected);
   }
 }
--- a/devtools/client/memory/test/unit/head.js
+++ b/devtools/client/memory/test/unit/head.js
@@ -26,17 +26,17 @@ var HeapAnalysesClient = require("devtoo
 var { addDebuggerToGlobal } = require("resource://gre/modules/jsdebugger.jsm");
 var Store = require("devtools/client/memory/store");
 var { L10N } = require("devtools/client/memory/utils");
 var SYSTEM_PRINCIPAL =
   Cc["@mozilla.org/systemprincipal;1"].createInstance(Ci.nsIPrincipal);
 
 var EXPECTED_DTU_ASSERT_FAILURE_COUNT = 0;
 
-do_register_cleanup(function () {
+registerCleanupFunction(function () {
   equal(DevToolsUtils.assertionFailureCount, EXPECTED_DTU_ASSERT_FAILURE_COUNT,
         "Should have had the expected number of DevToolsUtils.assert() failures.");
 });
 
 function dumpn(msg) {
   dump(`MEMORY-TEST: ${msg}\n`);
 }
 
@@ -73,21 +73,21 @@ StubbedMemoryFront.prototype.startRecord
 StubbedMemoryFront.prototype.stopRecordingAllocations = expectState("attached",
   Task.async(function* () {
     this.recordingAllocations = false;
   }));
 
 function waitUntilSnapshotState(store, expected) {
   let predicate = () => {
     let snapshots = store.getState().snapshots;
-    do_print(snapshots.map(x => x.state));
+    info(snapshots.map(x => x.state));
     return snapshots.length === expected.length &&
            expected.every((state, i) => state === "*" || snapshots[i].state === state);
   };
-  do_print(`Waiting for snapshots to be of state: ${expected}`);
+  info(`Waiting for snapshots to be of state: ${expected}`);
   return waitUntilState(store, predicate);
 }
 
 function findReportLeafIndex(node, name = null) {
   if (node.reportLeafIndex && (!name || node.name === name)) {
     return node.reportLeafIndex;
   }
 
@@ -102,28 +102,28 @@ function findReportLeafIndex(node, name 
 
   return null;
 }
 
 function waitUntilCensusState(store, getCensus, expected) {
   let predicate = () => {
     let snapshots = store.getState().snapshots;
 
-    do_print("Current census state:" +
-             snapshots.map(x => getCensus(x) ? getCensus(x).state : null));
+    info("Current census state:" +
+         snapshots.map(x => getCensus(x) ? getCensus(x).state : null));
 
     return snapshots.length === expected.length &&
            expected.every((state, i) => {
              let census = getCensus(snapshots[i]);
              return (state === "*") ||
                     (!census && !state) ||
                     (census && census.state === state);
            });
   };
-  do_print(`Waiting for snapshots' censuses to be of state: ${expected}`);
+  info(`Waiting for snapshots' censuses to be of state: ${expected}`);
   return waitUntilState(store, predicate);
 }
 
 function* createTempFile() {
   let file = FileUtils.getFile("TmpD", ["tmp.fxsnapshot"]);
   file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
   let destPath = file.path;
   let stat = yield OS.File.stat(destPath);
--- a/devtools/client/memory/test/unit/test_action-export-snapshot.js
+++ b/devtools/client/memory/test/unit/test_action-export-snapshot.js
@@ -24,14 +24,14 @@ add_task(function* () {
   let exportEvents = Promise.all([
     waitUntilAction(store, actions.EXPORT_SNAPSHOT_START),
     waitUntilAction(store, actions.EXPORT_SNAPSHOT_END)
   ]);
   dispatch(exportSnapshot(getState().snapshots[0], destPath));
   yield exportEvents;
 
   let stat = yield OS.File.stat(destPath);
-  do_print(stat.size);
+  info(stat.size);
   ok(stat.size > 0, "destination file is more than 0 bytes");
 
   heapWorker.destroy();
   yield front.detach();
 });
--- a/devtools/client/memory/test/unit/test_action-select-snapshot.js
+++ b/devtools/client/memory/test/unit/test_action-select-snapshot.js
@@ -18,17 +18,17 @@ add_task(function* () {
   for (let i = 0; i < 5; i++) {
     store.dispatch(actions.takeSnapshot(front));
   }
 
   yield waitUntilState(store,
     ({ snapshots }) => snapshots.length === 5 && snapshots.every(isDone));
 
   for (let i = 0; i < 5; i++) {
-    do_print(`Selecting snapshot[${i}]`);
+    info(`Selecting snapshot[${i}]`);
     store.dispatch(actions.selectSnapshot(store.getState().snapshots[i].id));
     yield waitUntilState(store, ({ snapshots }) => snapshots[i].selected);
 
     let { snapshots } = store.getState();
     ok(snapshots[i].selected, `snapshot[${i}] selected`);
     equal(snapshots.filter(s => !s.selected).length, 4,
           "All other snapshots are unselected");
   }
--- a/devtools/client/responsive.html/test/unit/head.js
+++ b/devtools/client/responsive.html/test/unit/head.js
@@ -11,11 +11,11 @@ const { require } = Cu.import("resource:
 const promise = require("promise");
 const { Task } = require("devtools/shared/task");
 const Store = require("devtools/client/responsive.html/store");
 
 const DevToolsUtils = require("devtools/shared/DevToolsUtils");
 
 const flags = require("devtools/shared/flags");
 flags.testing = true;
-do_register_cleanup(() => {
+registerCleanupFunction(() => {
   flags.testing = false;
 });
--- a/devtools/client/shared/redux/middleware/test/test_middleware-task-01.js
+++ b/devtools/client/shared/redux/middleware/test/test_middleware-task-01.js
@@ -43,14 +43,14 @@ function fetch1(data) {
 function fetch2(data) {
   return {
     type: "fetch2",
     data
   };
 }
 
 function reducer(state = [], action) {
-  do_print("Action called: " + action.type);
+  info("Action called: " + action.type);
   if (["fetch1", "fetch2"].includes(action.type)) {
     state.push(action);
   }
   return [...state];
 }
--- a/devtools/client/shared/redux/middleware/test/test_middleware-task-02.js
+++ b/devtools/client/shared/redux/middleware/test/test_middleware-task-02.js
@@ -54,14 +54,14 @@ function fetchAsync(data) {
     dispatch({ type: "fetchAsync-start" });
     let val = yield new Promise(resolve => resolve(data));
     dispatch({ type: "fetchAsync-end" });
     return val;
   };
 }
 
 function reducer(state = [], action) {
-  do_print("Action called: " + action.type);
+  info("Action called: " + action.type);
   if (/fetch/.test(action.type)) {
     state.push(action);
   }
   return [...state];
 }
--- a/devtools/client/shared/redux/middleware/test/test_middleware-task-03.js
+++ b/devtools/client/shared/redux/middleware/test/test_middleware-task-03.js
@@ -29,14 +29,14 @@ add_task(function* () {
 function generatorError() {
   return function* (dispatch, getState) {
     let error = "task-middleware-error-generator";
     throw error;
   };
 }
 
 function reducer(state = [], action) {
-  do_print("Action called: " + action.type);
+  info("Action called: " + action.type);
   if (action.type === ERROR_TYPE) {
     state.push(action);
   }
   return [...state];
 }
--- a/devtools/client/shared/test/unit/test_VariablesView_filtering-without-controller.js
+++ b/devtools/client/shared/test/unit/test_VariablesView_filtering-without-controller.js
@@ -21,16 +21,16 @@ function run_test() {
   let container = doc.body.firstChild;
   ok(container, "Got a container.");
 
   let vv = new VariablesView(container, { searchEnabled: true });
   let scope = vv.addScope("Test scope");
   let item1 = scope.addItem("a", { value: "1" });
   let item2 = scope.addItem("b", { value: "2" });
 
-  do_print("Performing a search without a controller.");
+  info("Performing a search without a controller.");
   vv._doSearch("a");
 
   equal(item1.target.hasAttribute("unmatched"), false,
     "First item that matched the filter is visible.");
   equal(item2.target.hasAttribute("unmatched"), true,
     "The second item that did not match the filter is hidden.");
 }
--- a/devtools/client/shared/test/unit/test_advanceValidate.js
+++ b/devtools/client/shared/test/unit/test_advanceValidate.js
@@ -11,17 +11,17 @@ const {utils: Cu, interfaces: Ci} = Comp
 const {require} = Cu.import("resource://devtools/shared/Loader.jsm", {});
 const {advanceValidate} = require("devtools/client/inspector/shared/utils");
 
 //                            1         2         3
 //                  0123456789012345678901234567890
 const sampleInput = '\\symbol "string" url(somewhere)';
 
 function testInsertion(where, result, testName) {
-  do_print(testName);
+  info(testName);
   equal(advanceValidate(Ci.nsIDOMKeyEvent.DOM_VK_SEMICOLON, sampleInput, where),
         result, "testing advanceValidate at " + where);
 }
 
 function run_test() {
   testInsertion(4, true, "inside a symbol");
   testInsertion(1, false, "after a backslash");
   testInsertion(8, true, "after whitespace");
--- a/devtools/client/shared/test/unit/test_attribute-parsing-01.js
+++ b/devtools/client/shared/test/unit/test_attribute-parsing-01.js
@@ -51,23 +51,23 @@ const TEST_DATA = [{
     {value: " ", type: "string"},
     {value: " ", type: "string"},
     {value: " ", type: "string"}
   ]
 }];
 
 function run_test() {
   for (let {value, splitChar, expected} of TEST_DATA) {
-    do_print("Splitting string: " + value);
+    info("Splitting string: " + value);
     let tokens = splitBy(value, splitChar);
 
-    do_print("Checking that the number of parsed tokens is correct");
-    do_check_eq(tokens.length, expected.length);
+    info("Checking that the number of parsed tokens is correct");
+    Assert.equal(tokens.length, expected.length);
 
     for (let i = 0; i < tokens.length; i++) {
-      do_print("Checking the data in token " + i);
-      do_check_eq(tokens[i].value, expected[i].value);
+      info("Checking the data in token " + i);
+      Assert.equal(tokens[i].value, expected[i].value);
       if (expected[i].type) {
-        do_check_eq(tokens[i].type, expected[i].type);
+        Assert.equal(tokens[i].type, expected[i].type);
       }
     }
   }
 }
--- a/devtools/client/shared/test/unit/test_attribute-parsing-02.js
+++ b/devtools/client/shared/test/unit/test_attribute-parsing-02.js
@@ -105,30 +105,30 @@ const TEST_DATA = [{
   expected: [
     {value: "script.js", type: "jsresource"}
   ]
 }];
 
 function run_test() {
   for (let {tagName, namespaceURI, attributeName,
             otherAttributes, attributeValue, expected} of TEST_DATA) {
-    do_print("Testing <" + tagName + " " + attributeName + "='" + attributeValue + "'>");
+    info("Testing <" + tagName + " " + attributeName + "='" + attributeValue + "'>");
 
     let attributes = [
       ...otherAttributes || [],
       { name: attributeName, value: attributeValue }
     ];
     let tokens = parseAttribute(namespaceURI, tagName, attributes, attributeName);
     if (!expected) {
-      do_check_true(!tokens);
+      Assert.ok(!tokens);
       continue;
     }
 
-    do_print("Checking that the number of parsed tokens is correct");
-    do_check_eq(tokens.length, expected.length);
+    info("Checking that the number of parsed tokens is correct");
+    Assert.equal(tokens.length, expected.length);
 
     for (let i = 0; i < tokens.length; i++) {
-      do_print("Checking the data in token " + i);
-      do_check_eq(tokens[i].value, expected[i].value);
-      do_check_eq(tokens[i].type, expected[i].type);
+      info("Checking the data in token " + i);
+      Assert.equal(tokens[i].value, expected[i].value);
+      Assert.equal(tokens[i].type, expected[i].type);
     }
   }
 }
--- a/devtools/client/shared/test/unit/test_bezierCanvas.js
+++ b/devtools/client/shared/test/unit/test_bezierCanvas.js
@@ -13,83 +13,83 @@ var {CubicBezier, BezierCanvas} = requir
 
 function run_test() {
   offsetsGetterReturnsData();
   convertsOffsetsToCoordinates();
   plotsCanvas();
 }
 
 function offsetsGetterReturnsData() {
-  do_print("offsets getter returns an array of 2 offset objects");
+  info("offsets getter returns an array of 2 offset objects");
 
   let b = new BezierCanvas(getCanvasMock(), getCubicBezier(), [.25, 0]);
   let offsets = b.offsets;
 
-  do_check_eq(offsets.length, 2);
+  Assert.equal(offsets.length, 2);
 
-  do_check_true("top" in offsets[0]);
-  do_check_true("left" in offsets[0]);
-  do_check_true("top" in offsets[1]);
-  do_check_true("left" in offsets[1]);
+  Assert.ok("top" in offsets[0]);
+  Assert.ok("left" in offsets[0]);
+  Assert.ok("top" in offsets[1]);
+  Assert.ok("left" in offsets[1]);
 
-  do_check_eq(offsets[0].top, "300px");
-  do_check_eq(offsets[0].left, "0px");
-  do_check_eq(offsets[1].top, "100px");
-  do_check_eq(offsets[1].left, "200px");
+  Assert.equal(offsets[0].top, "300px");
+  Assert.equal(offsets[0].left, "0px");
+  Assert.equal(offsets[1].top, "100px");
+  Assert.equal(offsets[1].left, "200px");
 
-  do_print("offsets getter returns data according to current padding");
+  info("offsets getter returns data according to current padding");
 
   b = new BezierCanvas(getCanvasMock(), getCubicBezier(), [0, 0]);
   offsets = b.offsets;
 
-  do_check_eq(offsets[0].top, "400px");
-  do_check_eq(offsets[0].left, "0px");
-  do_check_eq(offsets[1].top, "0px");
-  do_check_eq(offsets[1].left, "200px");
+  Assert.equal(offsets[0].top, "400px");
+  Assert.equal(offsets[0].left, "0px");
+  Assert.equal(offsets[1].top, "0px");
+  Assert.equal(offsets[1].left, "200px");
 }
 
 function convertsOffsetsToCoordinates() {
-  do_print("Converts offsets to coordinates");
+  info("Converts offsets to coordinates");
 
   let b = new BezierCanvas(getCanvasMock(), getCubicBezier(), [.25, 0]);
 
   let coordinates = b.offsetsToCoordinates({style: {
     left: "0px",
     top: "0px"
   }});
-  do_check_eq(coordinates.length, 2);
-  do_check_eq(coordinates[0], 0);
-  do_check_eq(coordinates[1], 1.5);
+  Assert.equal(coordinates.length, 2);
+  Assert.equal(coordinates[0], 0);
+  Assert.equal(coordinates[1], 1.5);
 
   coordinates = b.offsetsToCoordinates({style: {
     left: "0px",
     top: "300px"
   }});
-  do_check_eq(coordinates[0], 0);
-  do_check_eq(coordinates[1], 0);
+  Assert.equal(coordinates[0], 0);
+  Assert.equal(coordinates[1], 0);
 
   coordinates = b.offsetsToCoordinates({style: {
     left: "200px",
     top: "100px"
   }});
-  do_check_eq(coordinates[0], 1);
-  do_check_eq(coordinates[1], 1);
+  Assert.equal(coordinates[0], 1);
+  Assert.equal(coordinates[1], 1);
 }
 
 function plotsCanvas() {
-  do_print("Plots the curve to the canvas");
+  info("Plots the curve to the canvas");
 
   let hasDrawnCurve = false;
   let b = new BezierCanvas(getCanvasMock(), getCubicBezier(), [.25, 0]);
   b.ctx.bezierCurveTo = () => {
     hasDrawnCurve = true;
   };
   b.plot();
 
-  do_check_true(hasDrawnCurve);
+  Assert.ok(hasDrawnCurve);
 }
 
 function getCubicBezier() {
   return new CubicBezier([0, 0, 1, 1]);
 }
 
 function getCanvasMock(w = 200, h = 400) {
   return {
--- a/devtools/client/shared/test/unit/test_cubicBezier.js
+++ b/devtools/client/shared/test/unit/test_cubicBezier.js
@@ -46,75 +46,75 @@ function throwsWhenIncorrectCoordinates(
   }, "Throws an exception when coordinates are incorrect (time range invalid)");
 
   do_check_throws(() => {
     new CubicBezier([-0.5, 0, -0.5, 0]);
   }, "Throws an exception when coordinates are incorrect (time range invalid)");
 }
 
 function convertsStringCoordinates() {
-  do_print("Converts string coordinates to numbers");
+  info("Converts string coordinates to numbers");
   let c = new CubicBezier(["0", "1", ".5", "-2"]);
 
-  do_check_eq(c.coordinates[0], 0);
-  do_check_eq(c.coordinates[1], 1);
-  do_check_eq(c.coordinates[2], .5);
-  do_check_eq(c.coordinates[3], -2);
+  Assert.equal(c.coordinates[0], 0);
+  Assert.equal(c.coordinates[1], 1);
+  Assert.equal(c.coordinates[2], .5);
+  Assert.equal(c.coordinates[3], -2);
 }
 
 function coordinatesToStringOutputsAString() {
-  do_print("coordinates.toString() outputs a string representation");
+  info("coordinates.toString() outputs a string representation");
 
   let c = new CubicBezier(["0", "1", "0.5", "-2"]);
   let string = c.coordinates.toString();
-  do_check_eq(string, "0,1,.5,-2");
+  Assert.equal(string, "0,1,.5,-2");
 
   c = new CubicBezier([1, 1, 1, 1]);
   string = c.coordinates.toString();
-  do_check_eq(string, "1,1,1,1");
+  Assert.equal(string, "1,1,1,1");
 }
 
 function pointGettersReturnPointCoordinatesArrays() {
-  do_print("Points getters return arrays of coordinates");
+  info("Points getters return arrays of coordinates");
 
   let c = new CubicBezier([0, .2, .5, 1]);
-  do_check_eq(c.P1[0], 0);
-  do_check_eq(c.P1[1], .2);
-  do_check_eq(c.P2[0], .5);
-  do_check_eq(c.P2[1], 1);
+  Assert.equal(c.P1[0], 0);
+  Assert.equal(c.P1[1], .2);
+  Assert.equal(c.P2[0], .5);
+  Assert.equal(c.P2[1], 1);
 }
 
 function toStringOutputsCubicBezierValue() {
-  do_print("toString() outputs the cubic-bezier() value");
+  info("toString() outputs the cubic-bezier() value");
 
   let c = new CubicBezier([0, 1, 1, 0]);
-  do_check_eq(c.toString(), "cubic-bezier(0,1,1,0)");
+  Assert.equal(c.toString(), "cubic-bezier(0,1,1,0)");
 }
 
 function toStringOutputsCssPresetValues() {
-  do_print("toString() outputs the css predefined values");
+  info("toString() outputs the css predefined values");
 
   let c = new CubicBezier([0, 0, 1, 1]);
-  do_check_eq(c.toString(), "linear");
+  Assert.equal(c.toString(), "linear");
 
   c = new CubicBezier([0.25, 0.1, 0.25, 1]);
-  do_check_eq(c.toString(), "ease");
+  Assert.equal(c.toString(), "ease");
 
   c = new CubicBezier([0.42, 0, 1, 1]);
-  do_check_eq(c.toString(), "ease-in");
+  Assert.equal(c.toString(), "ease-in");
 
   c = new CubicBezier([0, 0, 0.58, 1]);
-  do_check_eq(c.toString(), "ease-out");
+  Assert.equal(c.toString(), "ease-out");
 
   c = new CubicBezier([0.42, 0, 0.58, 1]);
-  do_check_eq(c.toString(), "ease-in-out");
+  Assert.equal(c.toString(), "ease-in-out");
 }
 
 function testParseTimingFunction() {
-  do_print("test parseTimingFunction");
+  info("test parseTimingFunction");
 
   for (let test of ["ease", "linear", "ease-in", "ease-out", "ease-in-out"]) {
     ok(parseTimingFunction(test), test);
   }
 
   ok(!parseTimingFunction("something"), "non-function token");
   ok(!parseTimingFunction("something()"), "non-cubic-bezier function");
   ok(!parseTimingFunction("cubic-bezier(something)",
@@ -127,20 +127,20 @@ function testParseTimingFunction() {
   ok(!parseTimingFunction("cubic-bezier(1,2,", "early EOF after comma"));
   deepEqual(parseTimingFunction("cubic-bezier(1,2,3,7)"), [1, 2, 3, 7],
             "correct invocation");
   deepEqual(parseTimingFunction("cubic-bezier(1,  /* */ 2,3,   7  )"),
             [1, 2, 3, 7],
             "correct with comments and whitespace");
 }
 
-function do_check_throws(cb, info) {
-  do_print(info);
+function do_check_throws(cb, details) {
+  info(details);
 
   let hasThrown = false;
   try {
     cb();
   } catch (e) {
     hasThrown = true;
   }
 
-  do_check_true(hasThrown);
+  Assert.ok(hasThrown);
 }
--- a/devtools/client/shared/test/unit/test_escapeCSSComment.js
+++ b/devtools/client/shared/test/unit/test_escapeCSSComment.js
@@ -25,16 +25,16 @@ const TEST_DATA = [
     expected: "/\\* nested /\\\\* comment *\\\\/ *\\/",
   }
 ];
 
 function run_test() {
   let i = 0;
   for (let test of TEST_DATA) {
     ++i;
-    do_print("Test #" + i);
+    info("Test #" + i);
 
     let escaped = escapeCSSComment(test.input);
     equal(escaped, test.expected);
     let unescaped = _unescapeCSSComment(escaped);
     equal(unescaped, test.input);
   }
 }
--- a/devtools/client/shared/test/unit/test_parseDeclarations.js
+++ b/devtools/client/shared/test/unit/test_parseDeclarations.js
@@ -380,30 +380,30 @@ function run_test() {
   run_basic_tests();
   run_comment_tests();
   run_named_tests();
 }
 
 // Test parseDeclarations.
 function run_basic_tests() {
   for (let test of TEST_DATA) {
-    do_print("Test input string " + test.input);
+    info("Test input string " + test.input);
     let output;
     try {
       output = parseDeclarations(isCssPropertyKnown, test.input,
                                  test.parseComments);
     } catch (e) {
-      do_print("parseDeclarations threw an exception with the given input " +
+      info("parseDeclarations threw an exception with the given input " +
         "string");
       if (test.throws) {
-        do_print("Exception expected");
-        do_check_true(true);
+        info("Exception expected");
+        Assert.ok(true);
       } else {
-        do_print("Exception unexpected\n" + e);
-        do_check_true(false);
+        info("Exception unexpected\n" + e);
+        Assert.ok(false);
       }
     }
     if (output) {
       assertOutput(output, test.expected);
     }
   }
 }
 
@@ -418,17 +418,17 @@ const COMMENT_DATA = [
     input: "text that once confounded the parser;",
     expected: []
   },
 ];
 
 // Test parseCommentDeclarations.
 function run_comment_tests() {
   for (let test of COMMENT_DATA) {
-    do_print("Test input string " + test.input);
+    info("Test input string " + test.input);
     let output = _parseCommentDeclarations(isCssPropertyKnown, test.input, 0,
                                            test.input.length + 4);
     deepEqual(output, test.expected);
   }
 }
 
 const NAMED_DATA = [
   {
@@ -440,37 +440,37 @@ const NAMED_DATA = [
        offsets: [26, 38], colonOffsets: [32, 33]}
     ],
   },
 ];
 
 // Test parseNamedDeclarations.
 function run_named_tests() {
   for (let test of NAMED_DATA) {
-    do_print("Test input string " + test.input);
+    info("Test input string " + test.input);
     let output = parseNamedDeclarations(isCssPropertyKnown, test.input, true);
-    do_print(JSON.stringify(output));
+    info(JSON.stringify(output));
     deepEqual(output, test.expected);
   }
 }
 
 function assertOutput(actual, expected) {
   if (actual.length === expected.length) {
     for (let i = 0; i < expected.length; i++) {
-      do_check_true(!!actual[i]);
-      do_print("Check that the output item has the expected name, " +
+      Assert.ok(!!actual[i]);
+      info("Check that the output item has the expected name, " +
         "value and priority");
-      do_check_eq(expected[i].name, actual[i].name);
-      do_check_eq(expected[i].value, actual[i].value);
-      do_check_eq(expected[i].priority, actual[i].priority);
+      Assert.equal(expected[i].name, actual[i].name);
+      Assert.equal(expected[i].value, actual[i].value);
+      Assert.equal(expected[i].priority, actual[i].priority);
       deepEqual(expected[i].offsets, actual[i].offsets);
       if ("commentOffsets" in expected[i]) {
         deepEqual(expected[i].commentOffsets, actual[i].commentOffsets);
       }
     }
   } else {
     for (let prop of actual) {
-      do_print("Actual output contained: {name: " + prop.name + ", value: " +
+      info("Actual output contained: {name: " + prop.name + ", value: " +
         prop.value + ", priority: " + prop.priority + "}");
     }
-    do_check_eq(actual.length, expected.length);
+    Assert.equal(actual.length, expected.length);
   }
 }
--- a/devtools/client/shared/test/unit/test_parseSingleValue.js
+++ b/devtools/client/shared/test/unit/test_parseSingleValue.js
@@ -63,31 +63,31 @@ const TEST_DATA = [
       value: "\"all the \\\"'\\\\ special characters\"",
       priority: ""
     }
   }
 ];
 
 function run_test() {
   for (let test of TEST_DATA) {
-    do_print("Test input value " + test.input);
+    info("Test input value " + test.input);
     try {
       let output = parseSingleValue(isCssPropertyKnown, test.input);
       assertOutput(output, test.expected);
     } catch (e) {
-      do_print("parseSingleValue threw an exception with the given input " +
+      info("parseSingleValue threw an exception with the given input " +
         "value");
       if (test.throws) {
-        do_print("Exception expected");
-        do_check_true(true);
+        info("Exception expected");
+        Assert.ok(true);
       } else {
-        do_print("Exception unexpected\n" + e);
-        do_check_true(false);
+        info("Exception unexpected\n" + e);
+        Assert.ok(false);
       }
     }
   }
 }
 
 function assertOutput(actual, expected) {
-  do_print("Check that the output has the expected value and priority");
-  do_check_eq(expected.value, actual.value);
-  do_check_eq(expected.priority, actual.priority);
+  info("Check that the output has the expected value and priority");
+  Assert.equal(expected.value, actual.value);
+  Assert.equal(expected.priority, actual.priority);
 }
--- a/devtools/client/shared/test/unit/test_suggestion-picker.js
+++ b/devtools/client/shared/test/unit/test_suggestion-picker.js
@@ -39,17 +39,17 @@ const TEST_DATA = [
     // Empty items array.
     items: [],
     sortedItems: ["empty", "arrays", "can't", "have", "relevant", "indexes"],
     expectedIndex: -1
   }
 ];
 
 function ensureMostRelevantIndexProvidedByHelperFunction() {
-  do_print("Running ensureMostRelevantIndexProvidedByHelperFunction()");
+  info("Running ensureMostRelevantIndexProvidedByHelperFunction()");
 
   for (let testData of TEST_DATA) {
     let { items, sortedItems, expectedIndex } = testData;
     let mostRelevantIndex = findMostRelevantIndex(items, sortedItems);
     strictEqual(mostRelevantIndex, expectedIndex);
   }
 }
 
@@ -121,27 +121,27 @@ const CSS_TEST_DATA = [
       "word-wrap",
       "writing-mode"
     ],
     expectedIndex: 2
   }
 ];
 
 function ensureMostRelevantIndexProvidedByClassMethod() {
-  do_print("Running ensureMostRelevantIndexProvidedByClassMethod()");
+  info("Running ensureMostRelevantIndexProvidedByClassMethod()");
 
   for (let testData of CSS_TEST_DATA) {
     let { items, expectedIndex } = testData;
     let mostRelevantIndex = findMostRelevantCssPropertyIndex(items);
     strictEqual(mostRelevantIndex, expectedIndex);
   }
 }
 
 function ensureErrorThrownWithInvalidArguments() {
-  do_print("Running ensureErrorThrownWithInvalidTypeArgument()");
+  info("Running ensureErrorThrownWithInvalidTypeArgument()");
 
   let expectedError = "Please provide valid items and sortedItems arrays.";
   // No arguments passed.
   throws(() => findMostRelevantIndex(), expectedError);
   // Invalid arguments passed.
   throws(() => findMostRelevantIndex([]), expectedError);
   throws(() => findMostRelevantIndex(null, []), expectedError);
   throws(() => findMostRelevantIndex([], "string"), expectedError);
--- a/devtools/client/shared/test/unit/test_undoStack.js
+++ b/devtools/client/shared/test/unit/test_undoStack.js
@@ -27,72 +27,72 @@ function run_test() {
   function add(ch) {
     stack.do(function () {
       str += ch;
     }, function () {
       str = str.slice(0, -1);
     });
   }
 
-  do_check_false(stack.canUndo());
-  do_check_false(stack.canRedo());
+  Assert.ok(!stack.canUndo());
+  Assert.ok(!stack.canRedo());
 
   // Check adding up to the limit of the size
   add("a");
-  do_check_true(stack.canUndo());
-  do_check_false(stack.canRedo());
+  Assert.ok(stack.canUndo());
+  Assert.ok(!stack.canRedo());
 
   add("b");
   add("c");
   add("d");
   add("e");
 
-  do_check_eq(str, "abcde");
+  Assert.equal(str, "abcde");
 
   // Check a simple undo+redo
   stack.undo();
 
-  do_check_eq(str, "abcd");
-  do_check_true(stack.canRedo());
+  Assert.equal(str, "abcd");
+  Assert.ok(stack.canRedo());
 
   stack.redo();
-  do_check_eq(str, "abcde");
-  do_check_false(stack.canRedo());
+  Assert.equal(str, "abcde");
+  Assert.ok(!stack.canRedo());
 
   // Check an undo followed by a new action
   stack.undo();
-  do_check_eq(str, "abcd");
+  Assert.equal(str, "abcd");
 
   add("q");
-  do_check_eq(str, "abcdq");
-  do_check_false(stack.canRedo());
+  Assert.equal(str, "abcdq");
+  Assert.ok(!stack.canRedo());
 
   stack.undo();
-  do_check_eq(str, "abcd");
+  Assert.equal(str, "abcd");
   stack.redo();
-  do_check_eq(str, "abcdq");
+  Assert.equal(str, "abcdq");
 
   // Revert back to the beginning of the queue...
   while (stack.canUndo()) {
     stack.undo();
   }
-  do_check_eq(str, "");
+  Assert.equal(str, "");
 
   // Now put it all back....
   while (stack.canRedo()) {
     stack.redo();
   }
-  do_check_eq(str, "abcdq");
+  Assert.equal(str, "abcdq");
 
   // Now go over the undo limit...
   add("1");
   add("2");
   add("3");
 
-  do_check_eq(str, "abcdq123");
+  Assert.equal(str, "abcdq123");
 
   // And now undoing the whole stack should only undo 5 actions.
   while (stack.canUndo()) {
     stack.undo();
   }
 
-  do_check_eq(str, "abc");
+  Assert.equal(str, "abc");
 }
--- a/devtools/client/shared/vendor/stringvalidator/tests/unit/head_stringvalidator.js
+++ b/devtools/client/shared/vendor/stringvalidator/tests/unit/head_stringvalidator.js
@@ -5,16 +5,16 @@ var Cu = Components.utils;
 var Cr = Components.results;
 
 const { require } = Cu.import("resource://devtools/shared/Loader.jsm", {});
 const { console } = Cu.import("resource://gre/modules/Console.jsm", {});
 
 this.validator = require("devtools/client/shared/vendor/stringvalidator/validator");
 
 function describe(suite, testFunc) {
-  do_print(`\n                            Test suite: ${suite}`.toUpperCase());
+  info(`\n                            Test suite: ${suite}`.toUpperCase());
   testFunc();
 }
 
 function it(description, testFunc) {
-  do_print(`\n                              - ${description}:\n`.toUpperCase());
+  info(`\n                              - ${description}:\n`.toUpperCase());
   testFunc();
 }
--- a/devtools/client/sourceeditor/tern/tests/unit/test_autocompletion.js
+++ b/devtools/client/sourceeditor/tern/tests/unit/test_autocompletion.js
@@ -12,15 +12,15 @@ function run_test() {
   do_test_pending();
 
   const server = new tern.Server({ defs: [ecma5] });
   const code = "[].";
   const query = { type: "completions", file: "test", end: code.length };
   const files = [{ type: "full", name: "test", text: code }];
 
   server.request({ query: query, files: files }, (error, response) => {
-    do_check_eq(error, null);
-    do_check_true(!!response);
-    do_check_true(Array.isArray(response.completions));
-    do_check_true(response.completions.indexOf("concat") != -1);
+    Assert.equal(error, null);
+    Assert.ok(!!response);
+    Assert.ok(Array.isArray(response.completions));
+    Assert.ok(response.completions.indexOf("concat") != -1);
     do_test_finished();
   });
 }
--- a/devtools/client/sourceeditor/tern/tests/unit/test_import_tern.js
+++ b/devtools/client/sourceeditor/tern/tests/unit/test_import_tern.js
@@ -4,13 +4,13 @@
 /**
  * Test that we can require tern.
  */
 
 function run_test() {
   const tern = require("devtools/client/sourceeditor/tern/tern");
   const ecma5 = require("devtools/client/sourceeditor/tern/ecma5");
   const browser = require("devtools/client/sourceeditor/tern/browser");
-  do_check_true(!!tern);
-  do_check_true(!!ecma5);
-  do_check_true(!!browser);
-  do_check_eq(typeof tern.Server, "function");
+  Assert.ok(!!tern);
+  Assert.ok(!!ecma5);
+  Assert.ok(!!browser);
+  Assert.equal(typeof tern.Server, "function");
 }
--- a/devtools/platform/tests/unit/test_nsjsinspector.js
+++ b/devtools/platform/tests/unit/test_nsjsinspector.js
@@ -19,45 +19,47 @@ var requestor = (count) => ({
   connection: "conn" + (count % 3)
 });
 
 function run_test() {
   test_nesting();
 }
 
 function test_nesting() {
-  do_check_eq(inspector.eventLoopNestLevel, 0);
+  Assert.equal(inspector.eventLoopNestLevel, 0);
 
   tm.dispatchToMainThread({ run: enterEventLoop});
 
-  do_check_eq(inspector.enterNestedEventLoop(requestor(gCount)), 0);
-  do_check_eq(inspector.eventLoopNestLevel, 0);
-  do_check_eq(inspector.lastNestRequestor, null);
+  Assert.equal(inspector.enterNestedEventLoop(requestor(gCount)), 0);
+  Assert.equal(inspector.eventLoopNestLevel, 0);
+  Assert.equal(inspector.lastNestRequestor, null);
 }
 
 function enterEventLoop() {
   if (gCount++ < MAX) {
     tm.dispatchToMainThread({ run: enterEventLoop});
 
     Object.create(requestor(gCount));
 
-    do_check_eq(inspector.eventLoopNestLevel, gCount);
-    do_check_eq(inspector.lastNestRequestor.url, requestor(gCount - 1).url);
-    do_check_eq(inspector.lastNestRequestor.connection, requestor(gCount - 1).connection);
-    do_check_eq(inspector.enterNestedEventLoop(requestor(gCount)), gCount);
+    Assert.equal(inspector.eventLoopNestLevel, gCount);
+    Assert.equal(inspector.lastNestRequestor.url, requestor(gCount - 1).url);
+    Assert.equal(inspector.lastNestRequestor.connection,
+                 requestor(gCount - 1).connection);
+    Assert.equal(inspector.enterNestedEventLoop(requestor(gCount)), gCount);
   } else {
-    do_check_eq(gCount, MAX + 1);
+    Assert.equal(gCount, MAX + 1);
     tm.dispatchToMainThread({ run: exitEventLoop});
   }
 }
 
 function exitEventLoop() {
   if (inspector.lastNestRequestor != null) {
-    do_check_eq(inspector.lastNestRequestor.url, requestor(gCount - 1).url);
-    do_check_eq(inspector.lastNestRequestor.connection, requestor(gCount - 1).connection);
+    Assert.equal(inspector.lastNestRequestor.url, requestor(gCount - 1).url);
+    Assert.equal(inspector.lastNestRequestor.connection,
+                 requestor(gCount - 1).connection);
     if (gCount-- > 1) {
       tm.dispatchToMainThread({ run: exitEventLoop});
     }
 
-    do_check_eq(inspector.exitNestedEventLoop(), gCount);
-    do_check_eq(inspector.eventLoopNestLevel, gCount);
+    Assert.equal(inspector.exitNestedEventLoop(), gCount);
+    Assert.equal(inspector.eventLoopNestLevel, gCount);
   }
 }
--- a/devtools/server/tests/unit/head_dbg.js
+++ b/devtools/server/tests/unit/head_dbg.js
@@ -325,21 +325,21 @@ var listener = {
 
 var consoleService = Cc["@mozilla.org/consoleservice;1"].getService(Ci.nsIConsoleService);
 consoleService.registerListener(listener);
 
 function check_except(func) {
   try {
     func();
   } catch (e) {
-    do_check_true(true);
+    Assert.ok(true);
     return;
   }
   dumpn("Should have thrown an exception: " + func.toString());
-  do_check_true(false);
+  Assert.ok(false);
 }
 
 function testGlobal(name) {
   let sandbox = Cu.Sandbox(Cc["@mozilla.org/systemprincipal;1"]
                            .createInstance(Ci.nsIPrincipal));
   sandbox.__name = name;
   return sandbox;
 }
@@ -560,23 +560,23 @@ TracingTransport.prototype = {
     this.hooks.onPacket(packet);
   },
   onClosed: function () {
     this.hooks.onClosed();
   },
 
   expectSend: function (expected) {
     let packet = this.packets[this.checkIndex++];
-    do_check_eq(packet.type, "sent");
+    Assert.equal(packet.type, "sent");
     deepEqual(packet.packet, this.normalize(expected));
   },
 
   expectReceive: function (expected) {
     let packet = this.packets[this.checkIndex++];
-    do_check_eq(packet.type, "received");
+    Assert.equal(packet.type, "received");
     deepEqual(packet.packet, this.normalize(expected));
   },
 
   // Write your tests, call dumpLog at the end, inspect the output,
   // then sprinkle the calls through the right places in your test.
   dumpLog: function () {
     for (let entry of this.packets) {
       if (entry.type === "sent") {
@@ -588,55 +588,16 @@ TracingTransport.prototype = {
   }
 };
 
 function StubTransport() { }
 StubTransport.prototype.ready = function () {};
 StubTransport.prototype.send = function () {};
 StubTransport.prototype.close = function () {};
 
-function executeSoon(func) {
-  Services.tm.dispatchToMainThread({
-    run: DevToolsUtils.makeInfallible(func)
-  });
-}
-
-// The do_check_* family of functions expect their last argument to be an
-// optional stack object. Unfortunately, most tests actually pass a in a string
-// containing an error message instead, which causes error reporting to break if
-// strict warnings as errors is turned on. To avoid this, we wrap these
-// functions here below to ensure the correct number of arguments is passed.
-//
-// TODO: Remove this once bug 906232 is resolved
-//
-var do_check_true_old = do_check_true;
-var do_check_true = function (condition) {
-  do_check_true_old(condition);
-};
-
-var do_check_false_old = do_check_false;
-var do_check_false = function (condition) {
-  do_check_false_old(condition);
-};
-
-var do_check_eq_old = do_check_eq;
-var do_check_eq = function (left, right) {
-  do_check_eq_old(left, right);
-};
-
-var do_check_neq_old = do_check_neq;
-var do_check_neq = function (left, right) {
-  do_check_neq_old(left, right);
-};
-
-var do_check_matches_old = do_check_matches;
-var do_check_matches = function (pattern, value) {
-  do_check_matches_old(pattern, value);
-};
-
 // Create async version of the object where calling each method
 // is equivalent of calling it with asyncall. Mainly useful for
 // destructuring objects with methods that take callbacks.
 const Async = target => new Proxy(target, Async);
 Async.get = (target, name) =>
   typeof (target[name]) === "function" ? asyncall.bind(null, target[name], target) :
   target[name];
 
@@ -645,17 +606,17 @@ Async.get = (target, name) =>
 const asyncall = (fn, self, ...args) =>
   new Promise((...etc) => fn.call(self, ...args, ...etc));
 
 const Test = task => () => {
   add_task(task);
   run_next_test();
 };
 
-const assert = do_check_true;
+const assert = Assert.ok.bind(Assert);
 
 /**
  * Create a promise that is resolved on the next occurence of the given event.
  *
  * @param DebuggerClient client
  * @param String event
  * @param Function predicate
  * @returns Promise
--- a/devtools/server/tests/unit/test_actor-registry-actor.js
+++ b/devtools/server/tests/unit/test_actor-registry-actor.js
@@ -39,43 +39,43 @@ function registerNewActor() {
   };
 
   gRegistryFront
     .registerActor("resource://test/hello-actor.js", options)
     .then(actorFront => (gActorFront = actorFront))
     .then(talkToNewActor)
     .catch(e => {
       DevToolsUtils.reportException("registerNewActor", e);
-      do_check_true(false);
+      Assert.ok(false);
     });
 }
 
 function talkToNewActor() {
   gClient.listTabs(({ helloActor }) => {
-    do_check_true(!!helloActor);
+    Assert.ok(!!helloActor);
     gClient.request({
       to: helloActor,
       type: "hello"
     }, response => {
-      do_check_true(!response.error);
+      Assert.ok(!response.error);
       unregisterNewActor();
     });
   });
 }
 
 function unregisterNewActor() {
   gActorFront
     .unregister()
     .then(testActorIsUnregistered)
     .catch(e => {
       DevToolsUtils.reportException("unregisterNewActor", e);
-      do_check_true(false);
+      Assert.ok(false);
     });
 }
 
 function testActorIsUnregistered() {
   gClient.listTabs(({ helloActor }) => {
-    do_check_true(!helloActor);
+    Assert.ok(!helloActor);
 
     Services.prefs.setBoolPref("devtools.debugger.forbid-certified-apps", gOldPref);
     finishClient(gClient);
   });
 }
--- a/devtools/server/tests/unit/test_add_actors.js
+++ b/devtools/server/tests/unit/test_add_actors.js
@@ -41,44 +41,44 @@ function init() {
       gActors = response;
       run_next_test();
     });
 }
 
 function test_pre_init_global_actor() {
   gClient.request({ to: gActors.preInitGlobalActor, type: "ping" },
     function onResponse(response) {
-      do_check_eq(response.message, "pong");
+      Assert.equal(response.message, "pong");
       run_next_test();
     }
   );
 }
 
 function test_pre_init_tab_actor() {
   gClient.request({ to: gActors.preInitTabActor, type: "ping" },
     function onResponse(response) {
-      do_check_eq(response.message, "pong");
+      Assert.equal(response.message, "pong");
       run_next_test();
     }
   );
 }
 
 function test_post_init_global_actor() {
   gClient.request({ to: gActors.postInitGlobalActor, type: "ping" },
     function onResponse(response) {
-      do_check_eq(response.message, "pong");
+      Assert.equal(response.message, "pong");
       run_next_test();
     }
   );
 }
 
 function test_post_init_tab_actor() {
   gClient.request({ to: gActors.postInitTabActor, type: "ping" },
     function onResponse(response) {
-      do_check_eq(response.message, "pong");
+      Assert.equal(response.message, "pong");
       run_next_test();
     }
   );
 }
 
 // Get the object object, from the server side, for a given actor ID
 function getActorInstance(connID, actorID) {
   return DebuggerServer._connections[connID].getActor(actorID);
@@ -86,19 +86,19 @@ function getActorInstance(connID, actorI
 
 function test_stable_global_actor_instances() {
   // Consider that there is only one connection,
   // and the first one is ours
   let connID = Object.keys(DebuggerServer._connections)[0];
   let postInitGlobalActor = getActorInstance(connID, gActors.postInitGlobalActor);
   let preInitGlobalActor = getActorInstance(connID, gActors.preInitGlobalActor);
   gClient.listTabs(function onListTabs(response) {
-    do_check_eq(postInitGlobalActor,
-                getActorInstance(connID, response.postInitGlobalActor));
-    do_check_eq(preInitGlobalActor,
-                getActorInstance(connID, response.preInitGlobalActor));
+    Assert.equal(postInitGlobalActor,
+                 getActorInstance(connID, response.postInitGlobalActor));
+    Assert.equal(preInitGlobalActor,
+                 getActorInstance(connID, response.preInitGlobalActor));
     run_next_test();
   });
 }
 
 function close_client() {
   gClient.close().then(() => run_next_test());
 }
--- a/devtools/server/tests/unit/test_animation_name.js
+++ b/devtools/server/tests/unit/test_animation_name.js
@@ -72,16 +72,16 @@ function run_test() {
   }, {
     desc: "CSSAnimation without an id",
     animation: new window.CSSAnimation(),
     props: { animationName: "move" },
     expectedName: "move"
   }];
 
   for (let { desc, animation, props, expectedName } of TEST_DATA) {
-    do_print(desc);
+    info(desc);
     for (let key in props) {
       animation[key] = props[key];
     }
     let actor = AnimationPlayerActor({}, animation);
-    do_check_eq(actor.getName(), expectedName);
+    Assert.equal(actor.getName(), expectedName);
   }
 }
--- a/devtools/server/tests/unit/test_animation_type.js
+++ b/devtools/server/tests/unit/test_animation_type.js
@@ -56,13 +56,13 @@ function run_test() {
     expectedType: ANIMATION_TYPES.SCRIPT_ANIMATION
   }, {
     desc: "Test unknown type",
     animation: {effect: {target: getMockNode()}},
     expectedType: ANIMATION_TYPES.UNKNOWN
   }];
 
   for (let { desc, animation, expectedType } of TEST_DATA) {
-    do_print(desc);
+    info(desc);
     let actor = AnimationPlayerActor({}, animation);
-    do_check_eq(actor.getType(), expectedType);
+    Assert.equal(actor.getType(), expectedType);
   }
 }
--- a/devtools/server/tests/unit/test_attach.js
+++ b/devtools/server/tests/unit/test_attach.js
@@ -18,17 +18,17 @@ function run_test() {
       test_attach(tabClient);
     });
   });
   do_test_pending();
 }
 
 function test_attach(tabClient) {
   tabClient.attachThread({}, function (response, threadClient) {
-    do_check_eq(threadClient.state, "paused");
+    Assert.equal(threadClient.state, "paused");
     threadClient.resume(cleanup);
   });
 }
 
 function cleanup() {
   gClient.addListener("closed", function (event) {
     do_test_finished();
   });
--- a/devtools/server/tests/unit/test_blackboxing-01.js
+++ b/devtools/server/tests/unit/test_blackboxing-01.js
@@ -35,62 +35,62 @@ const testBlackBox = Task.async(function
   yield setBreakpoint(source, {
     line: 2
   });
   yield resume(gThreadClient);
 
   const { sources } = yield getSources(gThreadClient);
   let sourceClient = gThreadClient.source(
     sources.filter(s => s.url == BLACK_BOXED_URL)[0]);
-  do_check_true(!sourceClient.isBlackBoxed,
-                "By default the source is not black boxed.");
+  Assert.ok(!sourceClient.isBlackBoxed,
+            "By default the source is not black boxed.");
 
   // Test that we can step into `doStuff` when we are not black boxed.
   yield runTest(
     function onSteppedLocation(location) {
-      do_check_eq(location.source.url, BLACK_BOXED_URL);
-      do_check_eq(location.line, 2);
+      Assert.equal(location.source.url, BLACK_BOXED_URL);
+      Assert.equal(location.line, 2);
     },
     function onDebuggerStatementFrames(frames) {
-      do_check_true(!frames.some(f => f.where.source.isBlackBoxed));
+      Assert.ok(!frames.some(f => f.where.source.isBlackBoxed));
     }
   );
 
   yield blackBox(sourceClient);
-  do_check_true(sourceClient.isBlackBoxed);
+  Assert.ok(sourceClient.isBlackBoxed);
 
   // Test that we step through `doStuff` when we are black boxed and its frame
   // doesn't show up.
   yield runTest(
     function onSteppedLocation(location) {
-      do_check_eq(location.source.url, SOURCE_URL);
-      do_check_eq(location.line, 4);
+      Assert.equal(location.source.url, SOURCE_URL);
+      Assert.equal(location.line, 4);
     },
     function onDebuggerStatementFrames(frames) {
       for (let f of frames) {
         if (f.where.source.url == BLACK_BOXED_URL) {
-          do_check_true(f.where.source.isBlackBoxed);
+          Assert.ok(f.where.source.isBlackBoxed);
         } else {
-          do_check_true(!f.where.source.isBlackBoxed);
+          Assert.ok(!f.where.source.isBlackBoxed);
         }
       }
     }
   );
 
   yield unBlackBox(sourceClient);
-  do_check_true(!sourceClient.isBlackBoxed);
+  Assert.ok(!sourceClient.isBlackBoxed);
 
   // Test that we can step into `doStuff` again.
   yield runTest(
     function onSteppedLocation(location) {
-      do_check_eq(location.source.url, BLACK_BOXED_URL);
-      do_check_eq(location.line, 2);
+      Assert.equal(location.source.url, BLACK_BOXED_URL);
+      Assert.equal(location.line, 2);
     },
     function onDebuggerStatementFrames(frames) {
-      do_check_true(!frames.some(f => f.where.source.isBlackBoxed));
+      Assert.ok(!frames.some(f => f.where.source.isBlackBoxed));
     }
   );
 
   finishClient(gClient);
 });
 
 function evalCode() {
   /* eslint-disable */
@@ -120,27 +120,27 @@ function evalCode() {
     1
   );
   /* eslint-enable */
 }
 
 const runTest = Task.async(function* (onSteppedLocation, onDebuggerStatementFrames) {
   let packet = yield executeOnNextTickAndWaitForPause(gDebuggee.runTest,
                                                       gClient);
-  do_check_eq(packet.why.type, "breakpoint");
+  Assert.equal(packet.why.type, "breakpoint");
 
   yield stepIn(gClient, gThreadClient);
   yield stepIn(gClient, gThreadClient);
   yield stepIn(gClient, gThreadClient);
 
   const location = yield getCurrentLocation();
   onSteppedLocation(location);
 
   packet = yield resumeAndWaitForPause(gClient, gThreadClient);
-  do_check_eq(packet.why.type, "debuggerStatement");
+  Assert.equal(packet.why.type, "debuggerStatement");
 
   let { frames } = yield getFrames(gThreadClient, 0, 100);
   onDebuggerStatementFrames(frames);
 
   return resume(gThreadClient);
 });
 
 const getCurrentLocation = Task.async(function* () {
--- a/devtools/server/tests/unit/test_blackboxing-02.js
+++ b/devtools/server/tests/unit/test_blackboxing-02.js
@@ -41,17 +41,17 @@ function test_black_box() {
       });
     });
 
     function runWithSource(packet) {
       let source = gThreadClient.source(packet.source);
       source.setBreakpoint({
         line: 2
       }, function (response) {
-        do_check_true(!response.error, "Should be able to set breakpoint.");
+        Assert.ok(!response.error, "Should be able to set breakpoint.");
         gThreadClient.resume(test_black_box_breakpoint);
       });
     }
   });
 
   /* eslint-disable no-multi-spaces */
   Components.utils.evalInSandbox(
     "" + function doStuff(k) { // line 1
@@ -78,40 +78,40 @@ function test_black_box() {
     SOURCE_URL,
     1
   );
   /* eslint-enable no-multi-spaces */
 }
 
 function test_black_box_breakpoint() {
   gThreadClient.getSources(function ({error, sources}) {
-    do_check_true(!error, "Should not get an error: " + error);
+    Assert.ok(!error, "Should not get an error: " + error);
     let sourceClient = gThreadClient.source(
       sources.filter(s => s.url == BLACK_BOXED_URL)[0]
     );
     sourceClient.blackBox(function ({error}) {
-      do_check_true(!error, "Should not get an error: " + error);
+      Assert.ok(!error, "Should not get an error: " + error);
 
       gClient.addOneTimeListener("paused", function (event, packet) {
-        do_check_eq(
+        Assert.equal(
           packet.why.type, "debuggerStatement",
           "We should pass over the breakpoint since the source is black boxed.");
         gThreadClient.resume(test_unblack_box_breakpoint.bind(null, sourceClient));
       });
       gDebuggee.runTest();
     });
   });
 }
 
 function test_unblack_box_breakpoint(sourceClient) {
   sourceClient.unblackBox(function ({error}) {
-    do_check_true(!error, "Should not get an error: " + error);
+    Assert.ok(!error, "Should not get an error: " + error);
     gClient.addOneTimeListener("paused", function (event, packet) {
-      do_check_eq(packet.why.type, "breakpoint",
-                  "We should hit the breakpoint again");
+      Assert.equal(packet.why.type, "breakpoint",
+                   "We should hit the breakpoint again");
 
       // We will hit the debugger statement on resume, so do this
       // nastiness to skip over it.
       gClient.addOneTimeListener(
         "paused",
         gThreadClient.resume.bind(
           gThreadClient,
           finishClient.bind(null, gClient)));
--- a/devtools/server/tests/unit/test_blackboxing-03.js
+++ b/devtools/server/tests/unit/test_blackboxing-03.js
@@ -32,17 +32,17 @@ const SOURCE_URL = "http://example.com/s
 
 function test_black_box() {
   gClient.addOneTimeListener("paused", function (event, packet) {
     let source = gThreadClient.source(packet.frame.where.source);
     source.setBreakpoint({
       line: 4
     }, function ({error}, bpClient) {
       gBpClient = bpClient;
-      do_check_true(!error, "Should not get an error: " + error);
+      Assert.ok(!error, "Should not get an error: " + error);
       gThreadClient.resume(test_black_box_dbg_statement);
     });
   });
 
   /* eslint-disable no-multi-spaces */
   Components.utils.evalInSandbox(
     "" + function doStuff(k) { // line 1
       debugger;                // line 2 - Break here
@@ -68,41 +68,41 @@ function test_black_box() {
     SOURCE_URL,
     1
   );
   /* eslint-enable no-multi-spaces */
 }
 
 function test_black_box_dbg_statement() {
   gThreadClient.getSources(function ({error, sources}) {
-    do_check_true(!error, "Should not get an error: " + error);
+    Assert.ok(!error, "Should not get an error: " + error);
     let sourceClient = gThreadClient.source(
       sources.filter(s => s.url == BLACK_BOXED_URL)[0]
     );
 
     sourceClient.blackBox(function ({error}) {
-      do_check_true(!error, "Should not get an error: " + error);
+      Assert.ok(!error, "Should not get an error: " + error);
 
       gClient.addOneTimeListener("paused", function (event, packet) {
-        do_check_eq(packet.why.type, "breakpoint",
-                    "We should pass over the debugger statement.");
+        Assert.equal(packet.why.type, "breakpoint",
+                     "We should pass over the debugger statement.");
         gBpClient.remove(function ({error}) {
-          do_check_true(!error, "Should not get an error: " + error);
+          Assert.ok(!error, "Should not get an error: " + error);
           gThreadClient.resume(test_unblack_box_dbg_statement.bind(null, sourceClient));
         });
       });
       gDebuggee.runTest();
     });
   });
 }
 
 function test_unblack_box_dbg_statement(sourceClient) {
   sourceClient.unblackBox(function ({error}) {
-    do_check_true(!error, "Should not get an error: " + error);
+    Assert.ok(!error, "Should not get an error: " + error);
 
     gClient.addOneTimeListener("paused", function (event, packet) {
-      do_check_eq(packet.why.type, "debuggerStatement",
-                  "We should stop at the debugger statement again");
+      Assert.equal(packet.why.type, "debuggerStatement",
+                   "We should stop at the debugger statement again");
       finishClient(gClient);
     });
     gDebuggee.runTest();
   });
 }
--- a/devtools/server/tests/unit/test_blackboxing-04.js
+++ b/devtools/server/tests/unit/test_blackboxing-04.js
@@ -38,17 +38,17 @@ function test_black_box() {
       });
     });
 
     function runWithSource(packet) {
       let source = gThreadClient.source(packet.source);
       source.setBreakpoint({
         line: 2
       }, function (response) {
-        do_check_true(!response.error, "Should be able to set breakpoint.");
+        Assert.ok(!response.error, "Should be able to set breakpoint.");
         test_black_box_paused();
       });
     }
   });
 
   /* eslint-disable no-multi-spaces */
   Components.utils.evalInSandbox(
     "" + function doStuff(k) { // line 1
@@ -75,21 +75,21 @@ function test_black_box() {
     SOURCE_URL,
     1
   );
   /* eslint-enable no-multi-spaces */
 }
 
 function test_black_box_paused() {
   gThreadClient.getSources(function ({error, sources}) {
-    do_check_true(!error, "Should not get an error: " + error);
+    Assert.ok(!error, "Should not get an error: " + error);
     let sourceClient = gThreadClient.source(
       sources.filter(s => s.url == BLACK_BOXED_URL)[0]
     );
 
     sourceClient.blackBox(function ({error, pausedInSource}) {
-      do_check_true(!error, "Should not get an error: " + error);
-      do_check_true(pausedInSource,
-                    "We should be notified that we are currently paused in this source");
+      Assert.ok(!error, "Should not get an error: " + error);
+      Assert.ok(pausedInSource,
+                "We should be notified that we are currently paused in this source");
       finishClient(gClient);
     });
   });
 }
--- a/devtools/server/tests/unit/test_blackboxing-05.js
+++ b/devtools/server/tests/unit/test_blackboxing-05.js
@@ -65,27 +65,27 @@ function test_black_box() {
     SOURCE_URL,
     1
   );
   /* eslint-enable no-multi-spaces */
 }
 
 function test_black_box_exception() {
   gThreadClient.getSources(function ({error, sources}) {
-    do_check_true(!error, "Should not get an error: " + error);
+    Assert.ok(!error, "Should not get an error: " + error);
     let sourceClient = gThreadClient.source(
       sources.filter(s => s.url == BLACK_BOXED_URL)[0]
     );
 
     sourceClient.blackBox(function ({error}) {
-      do_check_true(!error, "Should not get an error: " + error);
+      Assert.ok(!error, "Should not get an error: " + error);
       gThreadClient.pauseOnExceptions(true);
 
       gClient.addOneTimeListener("paused", function (event, packet) {
-        do_check_eq(packet.frame.where.source.url, SOURCE_URL,
-                    "We shouldn't pause while in the black boxed source.");
+        Assert.equal(packet.frame.where.source.url, SOURCE_URL,
+                     "We shouldn't pause while in the black boxed source.");
         finishClient(gClient);
       });
 
       gThreadClient.resume();
     });
   });
 }
--- a/devtools/server/tests/unit/test_blackboxing-06.js
+++ b/devtools/server/tests/unit/test_blackboxing-06.js
@@ -24,17 +24,17 @@ function run_test() {
       function (response, tabClient, threadClient) {
         gThreadClient = threadClient;
 
         promise.resolve(setup_code())
           .then(black_box_code)
           .then(run_code)
           .then(test_correct_location)
           .catch(function (error) {
-            do_check_true(false, "Should not get an error, got " + error);
+            Assert.ok(false, "Should not get an error, got " + error);
           })
           .then(function () {
             finishClient(gClient);
           });
       });
   });
   do_test_pending();
 }
@@ -68,24 +68,24 @@ function setup_code() {
                                  "1.8",
                                  "http://example.com/abc.js");
 }
 
 function black_box_code() {
   const d = defer();
 
   gThreadClient.getSources(function ({ sources, error }) {
-    do_check_true(!error, "Shouldn't get an error getting sources");
+    Assert.ok(!error, "Shouldn't get an error getting sources");
     const source = sources.filter((s) => {
       return s.url.indexOf("b.js") !== -1;
     })[0];
-    do_check_true(!!source, "We should have our source in the sources list");
+    Assert.ok(!!source, "We should have our source in the sources list");
 
     gThreadClient.source(source).blackBox(function ({ error }) {
-      do_check_true(!error, "Should not get an error black boxing");
+      Assert.ok(!error, "Should not get an error black boxing");
       d.resolve(true);
     });
   });
 
   return d.promise;
 }
 
 function run_code() {
@@ -96,14 +96,14 @@ function run_code() {
     gThreadClient.resume();
   });
   gDebuggee.a();
 
   return d.promise;
 }
 
 function test_correct_location(packet) {
-  do_check_eq(packet.why.type, "debuggerStatement",
-              "Should hit a debugger statement.");
-  do_check_eq(packet.frame.where.source.url, "http://example.com/c.js",
-              "Should have skipped over the debugger statement in the" +
-              " black boxed source");
+  Assert.equal(packet.why.type, "debuggerStatement",
+               "Should hit a debugger statement.");
+  Assert.equal(packet.frame.where.source.url, "http://example.com/c.js",
+               "Should have skipped over the debugger statement in the" +
+               " black boxed source");
 }
--- a/devtools/server/tests/unit/test_breakpoint-01.js
+++ b/devtools/server/tests/unit/test_breakpoint-01.js
@@ -38,24 +38,24 @@ function test_simple_breakpoint() {
     let source = gThreadClient.source(packet.frame.where.source);
     let location = {
       line: gDebuggee.line0 + 3
     };
 
     source.setBreakpoint(location, function (response, bpClient) {
       gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(packet.type, "paused");
-        do_check_eq(packet.frame.where.source.actor, source.actor);
-        do_check_eq(packet.frame.where.line, location.line);
-        do_check_eq(packet.why.type, "breakpoint");
-        do_check_eq(packet.why.actors[0], bpClient.actor);
+        Assert.equal(packet.type, "paused");
+        Assert.equal(packet.frame.where.source.actor, source.actor);
+        Assert.equal(packet.frame.where.line, location.line);
+        Assert.equal(packet.why.type, "breakpoint");
+        Assert.equal(packet.why.actors[0], bpClient.actor);
         // Check that the breakpoint worked.
-        do_check_eq(gDebuggee.a, 1);
-        do_check_eq(gDebuggee.b, undefined);
+        Assert.equal(gDebuggee.a, 1);
+        Assert.equal(gDebuggee.b, undefined);
 
         // Remove the breakpoint.
         bpClient.remove(function (response) {
           gThreadClient.resume(function () {
             gClient.close().then(gCallback);
           });
         });
       });
--- a/devtools/server/tests/unit/test_breakpoint-02.js
+++ b/devtools/server/tests/unit/test_breakpoint-02.js
@@ -37,27 +37,27 @@ function run_test_with_server(server, ca
 function test_breakpoint_running() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let location = { line: gDebuggee.line0 + 3 };
 
     gThreadClient.resume();
 
     // Setting the breakpoint later should interrupt the debuggee.
     gThreadClient.addOneTimeListener("paused", function (event, packet) {
-      do_check_eq(packet.type, "paused");
-      do_check_eq(packet.why.type, "interrupted");
+      Assert.equal(packet.type, "paused");
+      Assert.equal(packet.why.type, "interrupted");
     });
 
     let source = gThreadClient.source(packet.frame.where.source);
     source.setBreakpoint(location, function (response) {
       // Eval scripts don't stick around long enough for the breakpoint to be set,
       // so just make sure we got the expected response from the actor.
-      do_check_neq(response.error, "noScript");
+      Assert.notEqual(response.error, "noScript");
 
-      do_execute_soon(function () {
+      executeSoon(function () {
         gClient.close().then(gCallback);
       });
     });
   });
 
   /* eslint-disable */
   Cu.evalInSandbox(
     "var line0 = Error().lineNumber;\n" +
--- a/devtools/server/tests/unit/test_breakpoint-03.js
+++ b/devtools/server/tests/unit/test_breakpoint-03.js
@@ -37,46 +37,46 @@ function run_test_with_server(server, ca
   });
 }
 
 var test_no_skip_breakpoint = Task.async(function* (source, location) {
   let [response, bpClient] = yield source.setBreakpoint(
     Object.assign({}, location, { noSliding: true })
   );
 
-  do_check_true(!response.actualLocation);
-  do_check_eq(bpClient.location.line, gDebuggee.line0 + 3);
+  Assert.ok(!response.actualLocation);
+  Assert.equal(bpClient.location.line, gDebuggee.line0 + 3);
   yield bpClient.remove();
 });
 
 var test_skip_breakpoint = function () {
   gThreadClient.addOneTimeListener("paused", Task.async(function* (event, packet) {
     let location = { line: gDebuggee.line0 + 3 };
     let source = gThreadClient.source(packet.frame.where.source);
 
     // First, make sure that we can disable sliding with the
     // `noSliding` option.
     yield test_no_skip_breakpoint(source, location);
 
     // Now make sure that the breakpoint properly slides forward one line.
     const [response, bpClient] = yield source.setBreakpoint(location);
-    do_check_true(!!response.actualLocation);
-    do_check_eq(response.actualLocation.source.actor, source.actor);
-    do_check_eq(response.actualLocation.line, location.line + 1);
+    Assert.ok(!!response.actualLocation);
+    Assert.equal(response.actualLocation.source.actor, source.actor);
+    Assert.equal(response.actualLocation.line, location.line + 1);
 
     gThreadClient.addOneTimeListener("paused", function (event, packet) {
       // Check the return value.
-      do_check_eq(packet.type, "paused");
-      do_check_eq(packet.frame.where.source.actor, source.actor);
-      do_check_eq(packet.frame.where.line, location.line + 1);
-      do_check_eq(packet.why.type, "breakpoint");
-      do_check_eq(packet.why.actors[0], bpClient.actor);
+      Assert.equal(packet.type, "paused");
+      Assert.equal(packet.frame.where.source.actor, source.actor);
+      Assert.equal(packet.frame.where.line, location.line + 1);
+      Assert.equal(packet.why.type, "breakpoint");
+      Assert.equal(packet.why.actors[0], bpClient.actor);
       // Check that the breakpoint worked.
-      do_check_eq(gDebuggee.a, 1);
-      do_check_eq(gDebuggee.b, undefined);
+      Assert.equal(gDebuggee.a, 1);
+      Assert.equal(gDebuggee.b, undefined);
 
       // Remove the breakpoint.
       bpClient.remove(function (response) {
         gThreadClient.resume(function () {
           gClient.close().then(gCallback);
         });
       });
     });
--- a/devtools/server/tests/unit/test_breakpoint-04.js
+++ b/devtools/server/tests/unit/test_breakpoint-04.js
@@ -36,28 +36,28 @@ function run_test_with_server(server, ca
 
 function test_child_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 3 };
 
     source.setBreakpoint(location, function (response, bpClient) {
       // actualLocation is not returned when breakpoints don't skip forward.
-      do_check_eq(response.actualLocation, undefined);
+      Assert.equal(response.actualLocation, undefined);
 
       gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(packet.type, "paused");
-        do_check_eq(packet.frame.where.source.actor, source.actor);
-        do_check_eq(packet.frame.where.line, location.line);
-        do_check_eq(packet.why.type, "breakpoint");
-        do_check_eq(packet.why.actors[0], bpClient.actor);
+        Assert.equal(packet.type, "paused");
+        Assert.equal(packet.frame.where.source.actor, source.actor);
+        Assert.equal(packet.frame.where.line, location.line);
+        Assert.equal(packet.why.type, "breakpoint");
+        Assert.equal(packet.why.actors[0], bpClient.actor);
         // Check that the breakpoint worked.
-        do_check_eq(gDebuggee.a, 1);
-        do_check_eq(gDebuggee.b, undefined);
+        Assert.equal(gDebuggee.a, 1);
+        Assert.equal(gDebuggee.b, undefined);
 
         // Remove the breakpoint.
         bpClient.remove(function (response) {
           gThreadClient.resume(function () {
             gClient.close().then(gCallback);
           });
         });
       });
--- a/devtools/server/tests/unit/test_breakpoint-05.js
+++ b/devtools/server/tests/unit/test_breakpoint-05.js
@@ -37,29 +37,29 @@ function run_test_with_server(server, ca
 
 function test_child_skip_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 3 };
 
     source.setBreakpoint(location, function (response, bpClient) {
       // Check that the breakpoint has properly skipped forward one line.
-      do_check_eq(response.actualLocation.source.actor, source.actor);
-      do_check_eq(response.actualLocation.line, location.line + 1);
+      Assert.equal(response.actualLocation.source.actor, source.actor);
+      Assert.equal(response.actualLocation.line, location.line + 1);
 
       gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(packet.type, "paused");
-        do_check_eq(packet.frame.where.source.actor, source.actor);
-        do_check_eq(packet.frame.where.line, location.line + 1);
-        do_check_eq(packet.why.type, "breakpoint");
-        do_check_eq(packet.why.actors[0], bpClient.actor);
+        Assert.equal(packet.type, "paused");
+        Assert.equal(packet.frame.where.source.actor, source.actor);
+        Assert.equal(packet.frame.where.line, location.line + 1);
+        Assert.equal(packet.why.type, "breakpoint");
+        Assert.equal(packet.why.actors[0], bpClient.actor);
         // Check that the breakpoint worked.
-        do_check_eq(gDebuggee.a, 1);
-        do_check_eq(gDebuggee.b, undefined);
+        Assert.equal(gDebuggee.a, 1);
+        Assert.equal(gDebuggee.b, undefined);
 
         // Remove the breakpoint.
         bpClient.remove(function (response) {
           gThreadClient.resume(function () {
             gClient.close().then(gCallback);
           });
         });
       });
--- a/devtools/server/tests/unit/test_breakpoint-06.js
+++ b/devtools/server/tests/unit/test_breakpoint-06.js
@@ -37,29 +37,29 @@ function run_test_with_server(server, ca
 
 function test_nested_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 5 };
 
     source.setBreakpoint(location, function (response, bpClient) {
       // Check that the breakpoint has properly skipped forward one line.
-      do_check_eq(response.actualLocation.source.actor, source.actor);
-      do_check_eq(response.actualLocation.line, location.line + 1);
+      Assert.equal(response.actualLocation.source.actor, source.actor);
+      Assert.equal(response.actualLocation.line, location.line + 1);
 
       gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(packet.type, "paused");
-        do_check_eq(packet.frame.where.source.actor, source.actor);
-        do_check_eq(packet.frame.where.line, location.line + 1);
-        do_check_eq(packet.why.type, "breakpoint");
-        do_check_eq(packet.why.actors[0], bpClient.actor);
+        Assert.equal(packet.type, "paused");
+        Assert.equal(packet.frame.where.source.actor, source.actor);
+        Assert.equal(packet.frame.where.line, location.line + 1);
+        Assert.equal(packet.why.type, "breakpoint");
+        Assert.equal(packet.why.actors[0], bpClient.actor);
         // Check that the breakpoint worked.
-        do_check_eq(gDebuggee.a, 1);
-        do_check_eq(gDebuggee.b, undefined);
+        Assert.equal(gDebuggee.a, 1);
+        Assert.equal(gDebuggee.b, undefined);
 
         // Remove the breakpoint.
         bpClient.remove(function (response) {
           gThreadClient.resume(function () {
             gClient.close().then(gCallback);
           });
         });
       });
--- a/devtools/server/tests/unit/test_breakpoint-07.js
+++ b/devtools/server/tests/unit/test_breakpoint-07.js
@@ -37,29 +37,29 @@ function run_test_with_server(server, ca
 
 function test_second_child_skip_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 6 };
 
     source.setBreakpoint(location, function (response, bpClient) {
       // Check that the breakpoint has properly skipped forward one line.
-      do_check_eq(response.actualLocation.source.actor, source.actor);
-      do_check_eq(response.actualLocation.line, location.line + 1);
+      Assert.equal(response.actualLocation.source.actor, source.actor);
+      Assert.equal(response.actualLocation.line, location.line + 1);
 
       gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(packet.type, "paused");
-        do_check_eq(packet.frame.where.source.actor, source.actor);
-        do_check_eq(packet.frame.where.line, location.line + 1);
-        do_check_eq(packet.why.type, "breakpoint");
-        do_check_eq(packet.why.actors[0], bpClient.actor);
+        Assert.equal(packet.type, "paused");
+        Assert.equal(packet.frame.where.source.actor, source.actor);
+        Assert.equal(packet.frame.where.line, location.line + 1);
+        Assert.equal(packet.why.type, "breakpoint");
+        Assert.equal(packet.why.actors[0], bpClient.actor);
         // Check that the breakpoint worked.
-        do_check_eq(gDebuggee.a, 1);
-        do_check_eq(gDebuggee.b, undefined);
+        Assert.equal(gDebuggee.a, 1);
+        Assert.equal(gDebuggee.b, undefined);
 
         // Remove the breakpoint.
         bpClient.remove(function (response) {
           gThreadClient.resume(function () {
             gClient.close().then(gCallback);
           });
         });
       });
--- a/devtools/server/tests/unit/test_breakpoint-08.js
+++ b/devtools/server/tests/unit/test_breakpoint-08.js
@@ -45,29 +45,29 @@ function test_child_skip_breakpoint() {
     });
 
     function runWithBreakpoint(packet) {
       let source = gThreadClient.source(packet.source);
       let location = { line: gDebuggee.line0 + 3 };
 
       source.setBreakpoint(location, function (response, bpClient) {
         // Check that the breakpoint has properly skipped forward one line.
-        do_check_eq(response.actualLocation.source.actor, source.actor);
-        do_check_eq(response.actualLocation.line, location.line + 1);
+        Assert.equal(response.actualLocation.source.actor, source.actor);
+        Assert.equal(response.actualLocation.line, location.line + 1);
 
         gThreadClient.addOneTimeListener("paused", function (event, packet) {
           // Check the return value.
-          do_check_eq(packet.type, "paused");
-          do_check_eq(packet.frame.where.source.actor, source.actor);
-          do_check_eq(packet.frame.where.line, location.line + 1);
-          do_check_eq(packet.why.type, "breakpoint");
-          do_check_eq(packet.why.actors[0], bpClient.actor);
+          Assert.equal(packet.type, "paused");
+          Assert.equal(packet.frame.where.source.actor, source.actor);
+          Assert.equal(packet.frame.where.line, location.line + 1);
+          Assert.equal(packet.why.type, "breakpoint");
+          Assert.equal(packet.why.actors[0], bpClient.actor);
           // Check that the breakpoint worked.
-          do_check_eq(gDebuggee.a, 1);
-          do_check_eq(gDebuggee.b, undefined);
+          Assert.equal(gDebuggee.a, 1);
+          Assert.equal(gDebuggee.b, undefined);
 
           // Remove the breakpoint.
           bpClient.remove(function (response) {
             gThreadClient.resume(function () {
               gClient.close().then(gCallback);
             });
           });
         });
--- a/devtools/server/tests/unit/test_breakpoint-09.js
+++ b/devtools/server/tests/unit/test_breakpoint-09.js
@@ -38,32 +38,32 @@ function test_remove_breakpoint() {
   let done = false;
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 2 };
 
     source.setBreakpoint(location, function (response, bpClient) {
       gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(packet.type, "paused");
-        do_check_eq(packet.frame.where.source.actor, source.actor);
-        do_check_eq(packet.frame.where.line, location.line);
-        do_check_eq(packet.why.type, "breakpoint");
-        do_check_eq(packet.why.actors[0], bpClient.actor);
+        Assert.equal(packet.type, "paused");
+        Assert.equal(packet.frame.where.source.actor, source.actor);
+        Assert.equal(packet.frame.where.line, location.line);
+        Assert.equal(packet.why.type, "breakpoint");
+        Assert.equal(packet.why.actors[0], bpClient.actor);
         // Check that the breakpoint worked.
-        do_check_eq(gDebuggee.a, undefined);
+        Assert.equal(gDebuggee.a, undefined);
 
         // Remove the breakpoint.
         bpClient.remove(function (response) {
           done = true;
           gThreadClient.addOneTimeListener("paused",
                                            function (event, packet) {
             // The breakpoint should not be hit again.
                                              gThreadClient.resume(function () {
-                                               do_check_true(false);
+                                               Assert.ok(false);
                                              });
                                            });
           gThreadClient.resume();
         });
       });
       // Continue until the breakpoint is hit.
       gThreadClient.resume();
     });
@@ -77,12 +77,12 @@ function test_remove_breakpoint() {
                    "  delete this.a;\n" +     // line0 + 4
                    "  foo(true);\n" +         // line0 + 5
                    "}\n" +                    // line0 + 6
                    "debugger;\n" +            // line1 + 7
                    "foo();\n",                // line1 + 8
                    gDebuggee);
   /* eslint-enable */
   if (!done) {
-    do_check_true(false);
+    Assert.ok(false);
   }
   gClient.close().then(gCallback);
 }
--- a/devtools/server/tests/unit/test_breakpoint-10.js
+++ b/devtools/server/tests/unit/test_breakpoint-10.js
@@ -37,33 +37,33 @@ function run_test_with_server(server, ca
 
 function test_child_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 3 };
 
     source.setBreakpoint(location, function (response, bpClient) {
       // actualLocation is not returned when breakpoints don't skip forward.
-      do_check_eq(response.actualLocation, undefined);
+      Assert.equal(response.actualLocation, undefined);
 
       gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(packet.type, "paused");
-        do_check_eq(packet.why.type, "breakpoint");
-        do_check_eq(packet.why.actors[0], bpClient.actor);
+        Assert.equal(packet.type, "paused");
+        Assert.equal(packet.why.type, "breakpoint");
+        Assert.equal(packet.why.actors[0], bpClient.actor);
         // Check that the breakpoint worked.
-        do_check_eq(gDebuggee.i, 0);
+        Assert.equal(gDebuggee.i, 0);
 
         gThreadClient.addOneTimeListener("paused", function (event, packet) {
           // Check the return value.
-          do_check_eq(packet.type, "paused");
-          do_check_eq(packet.why.type, "breakpoint");
-          do_check_eq(packet.why.actors[0], bpClient.actor);
+          Assert.equal(packet.type, "paused");
+          Assert.equal(packet.why.type, "breakpoint");
+          Assert.equal(packet.why.actors[0], bpClient.actor);
           // Check that the breakpoint worked.
-          do_check_eq(gDebuggee.i, 1);
+          Assert.equal(gDebuggee.i, 1);
 
           // Remove the breakpoint.
           bpClient.remove(function (response) {
             gThreadClient.resume(function () {
               gClient.close().then(gCallback);
             });
           });
         });
--- a/devtools/server/tests/unit/test_breakpoint-11.js
+++ b/devtools/server/tests/unit/test_breakpoint-11.js
@@ -37,34 +37,34 @@ function run_test_with_server(server, ca
 
 function test_child_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 2 };
 
     source.setBreakpoint(location, function (response, bpClient) {
       // actualLocation is not returned when breakpoints don't skip forward.
-      do_check_eq(response.actualLocation, undefined);
+      Assert.equal(response.actualLocation, undefined);
 
       gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(packet.type, "paused");
-        do_check_eq(packet.why.type, "breakpoint");
-        do_check_eq(packet.why.actors[0], bpClient.actor);
+        Assert.equal(packet.type, "paused");
+        Assert.equal(packet.why.type, "breakpoint");
+        Assert.equal(packet.why.actors[0], bpClient.actor);
         // Check that the breakpoint worked.
-        do_check_eq(gDebuggee.a, undefined);
+        Assert.equal(gDebuggee.a, undefined);
 
         gThreadClient.addOneTimeListener("paused", function (event, packet) {
           // Check the return value.
-          do_check_eq(packet.type, "paused");
-          do_check_eq(packet.why.type, "breakpoint");
-          do_check_eq(packet.why.actors[0], bpClient.actor);
+          Assert.equal(packet.type, "paused");
+          Assert.equal(packet.why.type, "breakpoint");
+          Assert.equal(packet.why.actors[0], bpClient.actor);
           // Check that the breakpoint worked.
-          do_check_eq(gDebuggee.a.b, 1);
-          do_check_eq(gDebuggee.res, undefined);
+          Assert.equal(gDebuggee.a.b, 1);
+          Assert.equal(gDebuggee.res, undefined);
 
           // Remove the breakpoint.
           bpClient.remove(function (response) {
             gThreadClient.resume(function () {
               gClient.close().then(gCallback);
             });
           });
         });
--- a/devtools/server/tests/unit/test_breakpoint-12.js
+++ b/devtools/server/tests/unit/test_breakpoint-12.js
@@ -41,18 +41,18 @@ function run_test_with_server(server, ca
 
 function test_child_skip_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 3};
 
     source.setBreakpoint(location, function (response, bpClient) {
       // Check that the breakpoint has properly skipped forward one line.
-      do_check_eq(response.actualLocation.source.actor, source.actor);
-      do_check_eq(response.actualLocation.line, location.line + 1);
+      Assert.equal(response.actualLocation.source.actor, source.actor);
+      Assert.equal(response.actualLocation.line, location.line + 1);
       gBpActor = response.actor;
 
       // Set more breakpoints at the same location.
       set_breakpoints(source, location);
     });
   });
 
   /* eslint-disable no-multi-spaces */
@@ -65,45 +65,45 @@ function test_child_skip_breakpoint() {
                    "debugger;\n" +        // line0 + 6
                    "foo();\n",            // line0 + 7
                    gDebuggee);
   /* eslint-enable no-multi-spaces */
 }
 
 // Set many breakpoints at the same location.
 function set_breakpoints(source, location) {
-  do_check_neq(gCount, NUM_BREAKPOINTS);
+  Assert.notEqual(gCount, NUM_BREAKPOINTS);
   source.setBreakpoint(location, function (response, bpClient) {
     // Check that the breakpoint has properly skipped forward one line.
-    do_check_eq(response.actualLocation.source.actor, source.actor);
-    do_check_eq(response.actualLocation.line, location.line + 1);
+    Assert.equal(response.actualLocation.source.actor, source.actor);
+    Assert.equal(response.actualLocation.line, location.line + 1);
     // Check that the same breakpoint actor was returned.
-    do_check_eq(response.actor, gBpActor);
+    Assert.equal(response.actor, gBpActor);
 
     if (++gCount < NUM_BREAKPOINTS) {
       set_breakpoints(source, location);
       return;
     }
 
     // After setting all the breakpoints, check that only one has effectively
     // remained.
     gThreadClient.addOneTimeListener("paused", function (event, packet) {
       // Check the return value.
-      do_check_eq(packet.type, "paused");
-      do_check_eq(packet.frame.where.source.actor, source.actor);
-      do_check_eq(packet.frame.where.line, location.line + 1);
-      do_check_eq(packet.why.type, "breakpoint");
-      do_check_eq(packet.why.actors[0], bpClient.actor);
+      Assert.equal(packet.type, "paused");
+      Assert.equal(packet.frame.where.source.actor, source.actor);
+      Assert.equal(packet.frame.where.line, location.line + 1);
+      Assert.equal(packet.why.type, "breakpoint");
+      Assert.equal(packet.why.actors[0], bpClient.actor);
       // Check that the breakpoint worked.
-      do_check_eq(gDebuggee.a, 1);
-      do_check_eq(gDebuggee.b, undefined);
+      Assert.equal(gDebuggee.a, 1);
+      Assert.equal(gDebuggee.b, undefined);
 
       gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // We don't expect any more pauses after the breakpoint was hit once.
-        do_check_true(false);
+        Assert.ok(false);
       });
       gThreadClient.resume(function () {
         // Give any remaining breakpoints a chance to trigger.
         do_timeout(1000, function () {
           gClient.close().then(gCallback);
         });
       });
     });
--- a/devtools/server/tests/unit/test_breakpoint-13.js
+++ b/devtools/server/tests/unit/test_breakpoint-13.js
@@ -39,58 +39,58 @@ function test_simple_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 2 };
 
     source.setBreakpoint(location, Task.async(function* (response, bpClient) {
       const testCallbacks = [
         function (packet) {
           // Check that the stepping worked.
-          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 5);
-          do_check_eq(packet.why.type, "resumeLimit");
+          Assert.equal(packet.frame.where.line, gDebuggee.line0 + 5);
+          Assert.equal(packet.why.type, "resumeLimit");
         },
         function (packet) {
           // Entered the foo function call frame.
-          do_check_eq(packet.frame.where.line, location.line);
-          do_check_neq(packet.why.type, "breakpoint");
-          do_check_eq(packet.why.type, "resumeLimit");
+          Assert.equal(packet.frame.where.line, location.line);
+          Assert.notEqual(packet.why.type, "breakpoint");
+          Assert.equal(packet.why.type, "resumeLimit");
         },
         function (packet) {
           // At the end of the foo function call frame.
-          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 3);
-          do_check_neq(packet.why.type, "breakpoint");
-          do_check_eq(packet.why.type, "resumeLimit");
+          Assert.equal(packet.frame.where.line, gDebuggee.line0 + 3);
+          Assert.notEqual(packet.why.type, "breakpoint");
+          Assert.equal(packet.why.type, "resumeLimit");
         },
         function (packet) {
           // Check that the breakpoint wasn't the reason for this pause, but
           // that the frame is about to be popped while stepping.
-          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 3);
-          do_check_neq(packet.why.type, "breakpoint");
-          do_check_eq(packet.why.type, "resumeLimit");
-          do_check_eq(packet.why.frameFinished.return.type, "undefined");
+          Assert.equal(packet.frame.where.line, gDebuggee.line0 + 3);
+          Assert.notEqual(packet.why.type, "breakpoint");
+          Assert.equal(packet.why.type, "resumeLimit");
+          Assert.equal(packet.why.frameFinished.return.type, "undefined");
         },
         function (packet) {
           // The foo function call frame was just popped from the stack.
-          do_check_eq(gDebuggee.a, 1);
-          do_check_eq(gDebuggee.b, undefined);
-          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 5);
-          do_check_eq(packet.why.type, "resumeLimit");
-          do_check_eq(packet.poppedFrames.length, 1);
+          Assert.equal(gDebuggee.a, 1);
+          Assert.equal(gDebuggee.b, undefined);
+          Assert.equal(packet.frame.where.line, gDebuggee.line0 + 5);
+          Assert.equal(packet.why.type, "resumeLimit");
+          Assert.equal(packet.poppedFrames.length, 1);
         },
         function (packet) {
           // Check that the debugger statement wasn't the reason for this pause.
-          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 6);
-          do_check_neq(packet.why.type, "debuggerStatement");
-          do_check_eq(packet.why.type, "resumeLimit");
+          Assert.equal(packet.frame.where.line, gDebuggee.line0 + 6);
+          Assert.notEqual(packet.why.type, "debuggerStatement");
+          Assert.equal(packet.why.type, "resumeLimit");
         },
         function (packet) {
           // Check that the debugger statement wasn't the reason for this pause.
-          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 7);
-          do_check_neq(packet.why.type, "debuggerStatement");
-          do_check_eq(packet.why.type, "resumeLimit");
+          Assert.equal(packet.frame.where.line, gDebuggee.line0 + 7);
+          Assert.notEqual(packet.why.type, "debuggerStatement");
+          Assert.equal(packet.why.type, "resumeLimit");
         },
       ];
 
       for (let callback of testCallbacks) {
         let waiter = waitForPause(gThreadClient);
         gThreadClient.stepIn();
         let packet = yield waiter;
         callback(packet);
--- a/devtools/server/tests/unit/test_breakpoint-14.js
+++ b/devtools/server/tests/unit/test_breakpoint-14.js
@@ -39,56 +39,56 @@ function test_simple_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 2 };
 
     source.setBreakpoint(location, Task.async(function* (response, bpClient) {
       const testCallbacks = [
         function (packet) {
           // Check that the stepping worked.
-          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 5);
-          do_check_eq(packet.why.type, "resumeLimit");
+          Assert.equal(packet.frame.where.line, gDebuggee.line0 + 5);
+          Assert.equal(packet.why.type, "resumeLimit");
         },
         function (packet) {
           // Reached the breakpoint.
-          do_check_eq(packet.frame.where.line, location.line);
-          do_check_eq(packet.why.type, "breakpoint");
-          do_check_neq(packet.why.type, "resumeLimit");
+          Assert.equal(packet.frame.where.line, location.line);
+          Assert.equal(packet.why.type, "breakpoint");
+          Assert.notEqual(packet.why.type, "resumeLimit");
         },
         function (packet) {
           // Stepped to the closing brace of the function.
-          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 3);
-          do_check_eq(packet.why.type, "resumeLimit");
+          Assert.equal(packet.frame.where.line, gDebuggee.line0 + 3);
+          Assert.equal(packet.why.type, "resumeLimit");
         },
         function (packet) {
           // The frame is about to be popped while stepping.
-          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 3);
-          do_check_neq(packet.why.type, "breakpoint");
-          do_check_eq(packet.why.type, "resumeLimit");
-          do_check_eq(packet.why.frameFinished.return.type, "undefined");
+          Assert.equal(packet.frame.where.line, gDebuggee.line0 + 3);
+          Assert.notEqual(packet.why.type, "breakpoint");
+          Assert.equal(packet.why.type, "resumeLimit");
+          Assert.equal(packet.why.frameFinished.return.type, "undefined");
         },
         function (packet) {
           // The foo function call frame was just popped from the stack.
-          do_check_eq(gDebuggee.a, 1);
-          do_check_eq(gDebuggee.b, undefined);
-          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 5);
-          do_check_eq(packet.why.type, "resumeLimit");
-          do_check_eq(packet.poppedFrames.length, 1);
+          Assert.equal(gDebuggee.a, 1);
+          Assert.equal(gDebuggee.b, undefined);
+          Assert.equal(packet.frame.where.line, gDebuggee.line0 + 5);
+          Assert.equal(packet.why.type, "resumeLimit");
+          Assert.equal(packet.poppedFrames.length, 1);
         },
         function (packet) {
           // Check that the debugger statement wasn't the reason for this pause.
-          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 6);
-          do_check_neq(packet.why.type, "debuggerStatement");
-          do_check_eq(packet.why.type, "resumeLimit");
+          Assert.equal(packet.frame.where.line, gDebuggee.line0 + 6);
+          Assert.notEqual(packet.why.type, "debuggerStatement");
+          Assert.equal(packet.why.type, "resumeLimit");
         },
         function (packet) {
           // Check that the debugger statement wasn't the reason for this pause.
-          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 7);
-          do_check_neq(packet.why.type, "debuggerStatement");
-          do_check_eq(packet.why.type, "resumeLimit");
+          Assert.equal(packet.frame.where.line, gDebuggee.line0 + 7);
+          Assert.notEqual(packet.why.type, "debuggerStatement");
+          Assert.equal(packet.why.type, "resumeLimit");
         },
       ];
 
       for (let callback of testCallbacks) {
         let waiter = waitForPause(gThreadClient);
         gThreadClient.stepOver();
         let packet = yield waiter;
         callback(packet);
--- a/devtools/server/tests/unit/test_breakpoint-15.js
+++ b/devtools/server/tests/unit/test_breakpoint-15.js
@@ -34,31 +34,31 @@ const testSameBreakpoint = Task.async(fu
   // Whole line
   let wholeLineLocation = {
     line: 2
   };
 
   let [, firstBpClient] = yield setBreakpoint(source, wholeLineLocation);
   let [, secondBpClient] = yield setBreakpoint(source, wholeLineLocation);
 
-  do_check_eq(firstBpClient.actor, secondBpClient.actor,
-              "Should get the same actor w/ whole line breakpoints");
+  Assert.equal(firstBpClient.actor, secondBpClient.actor,
+               "Should get the same actor w/ whole line breakpoints");
 
   // Specific column
 
   let columnLocation = {
     line: 2,
     column: 6
   };
 
   [, firstBpClient] = yield setBreakpoint(source, columnLocation);
   [, secondBpClient] = yield setBreakpoint(source, columnLocation);
 
-  do_check_eq(secondBpClient.actor, secondBpClient.actor,
-              "Should get the same actor column breakpoints");
+  Assert.equal(secondBpClient.actor, secondBpClient.actor,
+               "Should get the same actor column breakpoints");
 
   finishClient(gClient);
 });
 
 function evalCode() {
   /* eslint-disable */
   Components.utils.evalInSandbox(
     "" + function doStuff(k) { // line 1
--- a/devtools/server/tests/unit/test_breakpoint-16.js
+++ b/devtools/server/tests/unit/test_breakpoint-16.js
@@ -42,26 +42,26 @@ function test_column_breakpoint() {
     let location = {
       line: gDebuggee.line0 + 1,
       column: 55
     };
     let timesBreakpointHit = 0;
 
     source.setBreakpoint(location, function (response, bpClient) {
       gThreadClient.addListener("paused", function onPaused(event, packet) {
-        do_check_eq(packet.type, "paused");
-        do_check_eq(packet.why.type, "breakpoint");
-        do_check_eq(packet.why.actors[0], bpClient.actor);
-        do_check_eq(packet.frame.where.source.actor, source.actor);
-        do_check_eq(packet.frame.where.line, location.line);
-        do_check_eq(packet.frame.where.column, location.column);
+        Assert.equal(packet.type, "paused");
+        Assert.equal(packet.why.type, "breakpoint");
+        Assert.equal(packet.why.actors[0], bpClient.actor);
+        Assert.equal(packet.frame.where.source.actor, source.actor);
+        Assert.equal(packet.frame.where.line, location.line);
+        Assert.equal(packet.frame.where.column, location.column);
 
-        do_check_eq(gDebuggee.acc, timesBreakpointHit);
-        do_check_eq(packet.frame.environment.bindings.variables.i.value,
-                    timesBreakpointHit);
+        Assert.equal(gDebuggee.acc, timesBreakpointHit);
+        Assert.equal(packet.frame.environment.bindings.variables.i.value,
+                     timesBreakpointHit);
 
         if (++timesBreakpointHit === 3) {
           gThreadClient.removeListener("paused", onPaused);
           bpClient.remove(function (response) {
             gThreadClient.resume(() => gClient.close().then(gCallback));
           });
         } else {
           gThreadClient.resume();
--- a/devtools/server/tests/unit/test_breakpoint-17.js
+++ b/devtools/server/tests/unit/test_breakpoint-17.js
@@ -59,64 +59,64 @@ function test_breakpoints_columns() {
 }
 
 function set_breakpoints(event, packet) {
   let first, second;
   let source = gThreadClient.source(packet.frame.where.source);
 
   source.setBreakpoint(firstLocation, function ({ error, actualLocation },
                                         breakpointClient) {
-    do_check_true(!error, "Should not get an error setting the breakpoint");
-    do_check_true(!actualLocation, "Should not get an actualLocation");
+    Assert.ok(!error, "Should not get an error setting the breakpoint");
+    Assert.ok(!actualLocation, "Should not get an actualLocation");
     first = breakpointClient;
 
     source.setBreakpoint(secondLocation, function ({ error, actualLocation },
                                                           breakpointClient) {
-      do_check_true(!error, "Should not get an error setting the breakpoint");
-      do_check_true(!actualLocation, "Should not get an actualLocation");
+      Assert.ok(!error, "Should not get an error setting the breakpoint");
+      Assert.ok(!actualLocation, "Should not get an actualLocation");
       second = breakpointClient;
 
       test_different_actors(first, second);
     });
   });
 }
 
 function test_different_actors(first, second) {
-  do_check_neq(first.actor, second.actor,
-               "Each breakpoint should have a different actor");
+  Assert.notEqual(first.actor, second.actor,
+                  "Each breakpoint should have a different actor");
   test_remove_one(first, second);
 }
 
 function test_remove_one(first, second) {
   first.remove(function ({error}) {
-    do_check_true(!error, "Should not get an error removing a breakpoint");
+    Assert.ok(!error, "Should not get an error removing a breakpoint");
 
     let hitSecond;
     gClient.addListener("paused", function _onPaused(event, {why, frame}) {
       if (why.type == "breakpoint") {
         hitSecond = true;
-        do_check_eq(why.actors.length, 1,
-                    "Should only be paused because of one breakpoint actor");
-        do_check_eq(why.actors[0], second.actor,
-                    "Should be paused because of the correct breakpoint actor");
-        do_check_eq(frame.where.line, secondLocation.line,
-                    "Should be at the right line");
-        do_check_eq(frame.where.column, secondLocation.column,
-                    "Should be at the right column");
+        Assert.equal(why.actors.length, 1,
+                     "Should only be paused because of one breakpoint actor");
+        Assert.equal(why.actors[0], second.actor,
+                     "Should be paused because of the correct breakpoint actor");
+        Assert.equal(frame.where.line, secondLocation.line,
+                     "Should be at the right line");
+        Assert.equal(frame.where.column, secondLocation.column,
+                     "Should be at the right column");
         gThreadClient.resume();
         return;
       }
 
       if (why.type == "debuggerStatement") {
         gClient.removeListener("paused", _onPaused);
-        do_check_true(hitSecond,
-                      "We should still hit `second`, but not `first`.");
+        Assert.ok(hitSecond,
+                  "We should still hit `second`, but not `first`.");
 
         gClient.close().then(gCallback);
         return;
       }
 
-      do_check_true(false, "Should never get here");
+      Assert.ok(false, "Should never get here");
     });
 
     gThreadClient.resume(() => gDebuggee.foo());
   });
 }
--- a/devtools/server/tests/unit/test_breakpoint-18.js
+++ b/devtools/server/tests/unit/test_breakpoint-18.js
@@ -51,32 +51,32 @@ function setUpCode() {
   );
 }
 
 function setBreakpoint(event, packet) {
   let source = gThreadClient.source(packet.frame.where.source);
   gClient.addOneTimeListener("resumed", runCode);
 
   source.setBreakpoint({ line: 2 }, ({ error }) => {
-    do_check_true(!error);
+    Assert.ok(!error);
     gThreadClient.resume();
   });
 }
 
 function runCode() {
   gClient.addOneTimeListener("paused", testBPHit);
   gDebuggee.test();
 }
 
 function testBPHit(event, { why }) {
-  do_check_eq(why.type, "breakpoint");
+  Assert.equal(why.type, "breakpoint");
   gClient.addOneTimeListener("paused", testDbgStatement);
   gThreadClient.resume();
 }
 
 function testDbgStatement(event, { why }) {
   // Should continue to the debugger statement.
-  do_check_eq(why.type, "debuggerStatement");
+  Assert.equal(why.type, "debuggerStatement");
   // Not break on another offset from the same line (that isn't an entry point
   // to the line)
-  do_check_neq(why.type, "breakpoint");
+  Assert.notEqual(why.type, "breakpoint");
   gClient.close().then(gCallback);
 }
--- a/devtools/server/tests/unit/test_breakpoint-21.js
+++ b/devtools/server/tests/unit/test_breakpoint-21.js
@@ -45,21 +45,21 @@ const test = Task.async(function* () {
     line: gDebuggee.line0 + 8
   };
 
   let [res, bpClient] = yield setBreakpoint(source, location);
   ok(!res.error);
 
   yield resume(gThreadClient);
   packet = yield waitForPause(gClient);
-  do_check_eq(packet.type, "paused");
-  do_check_eq(packet.why.type, "breakpoint");
-  do_check_eq(packet.why.actors[0], bpClient.actor);
-  do_check_eq(packet.frame.where.source.actor, source.actor);
-  do_check_eq(packet.frame.where.line, location.line);
+  Assert.equal(packet.type, "paused");
+  Assert.equal(packet.why.type, "breakpoint");
+  Assert.equal(packet.why.actors[0], bpClient.actor);
+  Assert.equal(packet.frame.where.source.actor, source.actor);
+  Assert.equal(packet.frame.where.line, location.line);
 
   yield resume(gThreadClient);
   finishClient(gClient);
 });
 
 /* eslint-disable */
 function evalCode() {
   // Start a new script
--- a/devtools/server/tests/unit/test_breakpoint-22.js
+++ b/devtools/server/tests/unit/test_breakpoint-22.js
@@ -49,17 +49,17 @@ const test = Task.async(function* () {
 
   let location2 = {
     line: gDebuggee.line0 + 7
   };
 
   yield source.setBreakpoint(location2).then(_ => {
     do_throw("no code shall not be found the specified line or below it");
   }, reason => {
-    do_check_eq(reason.error, "noCodeAtLineColumn");
+    Assert.equal(reason.error, "noCodeAtLineColumn");
     ok(reason.message);
   });
 
   yield resume(gThreadClient);
   finishClient(gClient);
 });
 
 function evalCode() {
--- a/devtools/server/tests/unit/test_breakpoint-actor-map.js
+++ b/devtools/server/tests/unit/test_breakpoint-actor-map.js
@@ -24,84 +24,84 @@ function test_get_actor() {
   };
   let columnLocation = {
     originalSourceActor: { actor: "actor2" },
     originalLine: 5,
     originalColumn: 15
   };
 
   // Shouldn't have breakpoint
-  do_check_eq(null, bpStore.getActor(location),
-              "Breakpoint not added and shouldn't exist.");
+  Assert.equal(null, bpStore.getActor(location),
+               "Breakpoint not added and shouldn't exist.");
 
   bpStore.setActor(location, {});
-  do_check_true(!!bpStore.getActor(location),
-                "Breakpoint added but not found in Breakpoint Store.");
+  Assert.ok(!!bpStore.getActor(location),
+            "Breakpoint added but not found in Breakpoint Store.");
 
   bpStore.deleteActor(location);
-  do_check_eq(null, bpStore.getActor(location),
-              "Breakpoint removed but still exists.");
+  Assert.equal(null, bpStore.getActor(location),
+               "Breakpoint removed but still exists.");
 
   // Same checks for breakpoint with a column
-  do_check_eq(null, bpStore.getActor(columnLocation),
-              "Breakpoint with column not added and shouldn't exist.");
+  Assert.equal(null, bpStore.getActor(columnLocation),
+               "Breakpoint with column not added and shouldn't exist.");
 
   bpStore.setActor(columnLocation, {});
-  do_check_true(!!bpStore.getActor(columnLocation),
-                "Breakpoint with column added but not found in Breakpoint Store.");
+  Assert.ok(!!bpStore.getActor(columnLocation),
+            "Breakpoint with column added but not found in Breakpoint Store.");
 
   bpStore.deleteActor(columnLocation);
-  do_check_eq(null, bpStore.getActor(columnLocation),
-              "Breakpoint with column removed but still exists in Breakpoint Store.");
+  Assert.equal(null, bpStore.getActor(columnLocation),
+               "Breakpoint with column removed but still exists in Breakpoint Store.");
 }
 
 function test_set_actor() {
   // Breakpoint with column
   let bpStore = new BreakpointActorMap();
   let location = {
     originalSourceActor: { actor: "actor1" },
     originalLine: 10,
     originalColumn: 9
   };
   bpStore.setActor(location, {});
-  do_check_true(!!bpStore.getActor(location),
-                "We should have the column breakpoint we just added");
+  Assert.ok(!!bpStore.getActor(location),
+            "We should have the column breakpoint we just added");
 
   // Breakpoint without column (whole line breakpoint)
   location = {
     originalSourceActor: { actor: "actor2" },
     originalLine: 103
   };
   bpStore.setActor(location, {});
-  do_check_true(!!bpStore.getActor(location),
-                "We should have the whole line breakpoint we just added");
+  Assert.ok(!!bpStore.getActor(location),
+            "We should have the whole line breakpoint we just added");
 }
 
 function test_delete_actor() {
   // Breakpoint with column
   let bpStore = new BreakpointActorMap();
   let location = {
     originalSourceActor: { actor: "actor1" },
     originalLine: 10,
     originalColumn: 9
   };
   bpStore.setActor(location, {});
   bpStore.deleteActor(location);
-  do_check_eq(bpStore.getActor(location), null,
-              "We should not have the column breakpoint anymore");
+  Assert.equal(bpStore.getActor(location), null,
+               "We should not have the column breakpoint anymore");
 
   // Breakpoint without column (whole line breakpoint)
   location = {
     originalSourceActor: { actor: "actor2" },
     originalLine: 103
   };
   bpStore.setActor(location, {});
   bpStore.deleteActor(location);
-  do_check_eq(bpStore.getActor(location), null,
-              "We should not have the whole line breakpoint anymore");
+  Assert.equal(bpStore.getActor(location), null,
+               "We should not have the whole line breakpoint anymore");
 }
 
 function test_find_actors() {
   let bps = [
     { originalSourceActor: { actor: "actor1" }, originalLine: 10 },
     { originalSourceActor: { actor: "actor1" }, originalLine: 10, originalColumn: 3 },
     { originalSourceActor: { actor: "actor1" }, originalLine: 10, originalColumn: 10 },
     { originalSourceActor: { actor: "actor1" }, originalLine: 23, originalColumn: 89 },
@@ -118,68 +118,68 @@ function test_find_actors() {
   }
 
   // All breakpoints
 
   let bpSet = new Set(bps);
   for (let bp of bpStore.findActors()) {
     bpSet.delete(bp);
   }
-  do_check_eq(bpSet.size, 0,
-              "Should be able to iterate over all breakpoints");
+  Assert.equal(bpSet.size, 0,
+               "Should be able to iterate over all breakpoints");
 
   // Breakpoints by URL
 
   bpSet = new Set(bps.filter(bp => {
     return bp.originalSourceActor.actorID === "actor1";
   }));
   for (let bp of bpStore.findActors({ originalSourceActor: { actorID: "actor1" } })) {
     bpSet.delete(bp);
   }
-  do_check_eq(bpSet.size, 0,
-              "Should be able to filter the iteration by url");
+  Assert.equal(bpSet.size, 0,
+               "Should be able to filter the iteration by url");
 
   // Breakpoints by URL and line
 
   bpSet = new Set(bps.filter(bp => {
     return bp.originalSourceActor.actorID === "actor1" && bp.originalLine === 10;
   }));
   let first = true;
   for (let bp of bpStore.findActors({ originalSourceActor: { actorID: "actor1" },
                                       originalLine: 10 })) {
     if (first) {
-      do_check_eq(bp.originalColumn, undefined,
-                  "Should always get the whole line breakpoint first");
+      Assert.equal(bp.originalColumn, undefined,
+                   "Should always get the whole line breakpoint first");
       first = false;
     } else {
-      do_check_neq(bp.originalColumn, undefined,
-                   "Should not get the whole line breakpoint any time other than first.");
+      Assert.notEqual(bp.originalColumn, undefined,
+        "Should not get the whole line breakpoint any time other than first.");
     }
     bpSet.delete(bp);
   }
-  do_check_eq(bpSet.size, 0,
-              "Should be able to filter the iteration by url and line");
+  Assert.equal(bpSet.size, 0,
+               "Should be able to filter the iteration by url and line");
 }
 
 function test_duplicate_actors() {
   let bpStore = new BreakpointActorMap();
 
   // Breakpoint with column
   let location = {
     originalSourceActor: { actorID: "foo-actor" },
     originalLine: 10,
     originalColumn: 9
   };
   bpStore.setActor(location, {});
   bpStore.setActor(location, {});
-  do_check_eq(bpStore.size, 1, "We should have only 1 column breakpoint");
+  Assert.equal(bpStore.size, 1, "We should have only 1 column breakpoint");
   bpStore.deleteActor(location);
 
   // Breakpoint without column (whole line breakpoint)
   location = {
     originalSourceActor: { actorID: "foo-actor" },
     originalLine: 15
   };
   bpStore.setActor(location, {});
   bpStore.setActor(location, {});
-  do_check_eq(bpStore.size, 1, "We should have only 1 whole line breakpoint");
+  Assert.equal(bpStore.size, 1, "We should have only 1 whole line breakpoint");
   bpStore.deleteActor(location);
 }
--- a/devtools/server/tests/unit/test_client_request.js
+++ b/devtools/server/tests/unit/test_client_request.js
@@ -50,89 +50,89 @@ function init() {
     .then(response => {
       gActorId = response.test;
       run_next_test();
     });
 }
 
 function checkStack(expectedName) {
   if (!Services.prefs.getBoolPref("javascript.options.asyncstack")) {
-    do_print("Async stacks are disabled.");
+    info("Async stacks are disabled.");
     return;
   }
 
   let stack = Components.stack;
   while (stack) {
-    do_print(stack.name);
+    info(stack.name);
     if (stack.name == expectedName) {
       // Reached back to outer function before request
       ok(true, "Complete stack");
       return;
     }
     stack = stack.asyncCaller || stack.caller;
   }
   ok(false, "Incomplete stack");
 }
 
 function test_client_request_callback() {
   // Test that DebuggerClient.request accepts a `onResponse` callback as 2nd argument
   gClient.request({
     to: gActorId,
     type: "hello"
   }, response => {
-    do_check_eq(response.from, gActorId);
-    do_check_eq(response.hello, "world");
+    Assert.equal(response.from, gActorId);
+    Assert.equal(response.hello, "world");
     checkStack("test_client_request_callback");
     run_next_test();
   });
 }
 
 function test_client_request_promise() {
   // Test that DebuggerClient.request returns a promise that resolves on response
   let request = gClient.request({
     to: gActorId,
     type: "hello"
   });
 
   request.then(response => {
-    do_check_eq(response.from, gActorId);
-    do_check_eq(response.hello, "world");
+    Assert.equal(response.from, gActorId);
+    Assert.equal(response.hello, "world");
     checkStack("test_client_request_promise");
     run_next_test();
   });
 }
 
 function test_client_request_promise_error() {
   // Test that DebuggerClient.request returns a promise that reject when server
   // returns an explicit error message
   let request = gClient.request({
     to: gActorId,
     type: "error"
   });
 
   request.then(() => {
     do_throw("Promise shouldn't be resolved on error");
   }, response => {
-    do_check_eq(response.from, gActorId);
-    do_check_eq(response.error, "code");
-    do_check_eq(response.message, "human message");
+    Assert.equal(response.from, gActorId);
+    Assert.equal(response.error, "code");
+    Assert.equal(response.message, "human message");
     checkStack("test_client_request_promise_error");
     run_next_test();
   });
 }
 
 function test_client_request_event_emitter() {
   // Test that DebuggerClient.request returns also an EventEmitter object
   let request = gClient.request({
     to: gActorId,
     type: "hello"
   });
   request.on("json-reply", reply => {
-    do_check_eq(reply.from, gActorId);
-    do_check_eq(reply.hello, "world");
+    Assert.equal(reply.from, gActorId);
+    Assert.equal(reply.hello, "world");
     checkStack("test_client_request_event_emitter");
     run_next_test();
   });
 }
 
 function test_close_client_while_sending_requests() {
   // First send a first request that will be "active"
   // while the connection is closed.
@@ -146,37 +146,37 @@ function test_close_client_while_sending
   // i.e. won't event be sent.
   let pendingRequest = gClient.request({
     to: gActorId,
     type: "hello"
   });
 
   let expectReply = defer();
   gClient.expectReply("root", function (response) {
-    do_check_eq(response.error, "connectionClosed");
-    do_check_eq(response.message,
-                "server side packet can't be received as the connection just closed.");
+    Assert.equal(response.error, "connectionClosed");
+    Assert.equal(response.message,
+                 "server side packet can't be received as the connection just closed.");
     expectReply.resolve();
   });
 
   gClient.close().then(() => {
     activeRequest.then(() => {
       ok(false, "First request unexpectedly succeed while closing the connection");
     }, response => {
-      do_check_eq(response.error, "connectionClosed");
-      do_check_eq(response.message, "'hello' active request packet to '" +
-                  gActorId + "' can't be sent as the connection just closed.");
+      Assert.equal(response.error, "connectionClosed");
+      Assert.equal(response.message, "'hello' active request packet to '" +
+                   gActorId + "' can't be sent as the connection just closed.");
     })
     .then(() => pendingRequest)
     .then(() => {
       ok(false, "Second request unexpectedly succeed while closing the connection");
     }, response => {
-      do_check_eq(response.error, "connectionClosed");
-      do_check_eq(response.message, "'hello' pending request packet to '" +
-                  gActorId + "' can't be sent as the connection just closed.");
+      Assert.equal(response.error, "connectionClosed");
+      Assert.equal(response.message, "'hello' pending request packet to '" +
+                   gActorId + "' can't be sent as the connection just closed.");
     })
     .then(() => expectReply.promise)
     .then(run_next_test);
   });
 }
 
 function test_client_request_after_close() {
   // Test that DebuggerClient.request fails after we called client.close()
@@ -185,29 +185,29 @@ function test_client_request_after_close
     to: gActorId,
     type: "hello"
   });
 
   request.then(response => {
     ok(false, "Request succeed even after client.close");
   }, response => {
     ok(true, "Request failed after client.close");
-    do_check_eq(response.error, "connectionClosed");
+    Assert.equal(response.error, "connectionClosed");
     ok(response.message.match(
         /'hello' request packet to '.*' can't be sent as the connection is closed./));
     run_next_test();
   });
 }
 
 function test_client_request_after_close_callback() {
   // Test that DebuggerClient.request fails after we called client.close()
   // (with callback API)
   gClient.request({
     to: gActorId,
     type: "hello"
   }, response => {
     ok(true, "Request failed after client.close");
-    do_check_eq(response.error, "connectionClosed");
+    Assert.equal(response.error, "connectionClosed");
     ok(response.message.match(
         /'hello' request packet to '.*' can't be sent as the connection is closed./));
     run_next_test();
   });
 }
--- a/devtools/server/tests/unit/test_conditional_breakpoint-01.js
+++ b/devtools/server/tests/unit/test_conditional_breakpoint-01.js
@@ -30,18 +30,18 @@ function test_simple_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let source = gThreadClient.source(packet.frame.where.source);
     source.setBreakpoint({
       line: 3,
       condition: "a === 1"
     }, function (response, bpClient) {
       gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(packet.why.type, "breakpoint");
-        do_check_eq(packet.frame.where.line, 3);
+        Assert.equal(packet.why.type, "breakpoint");
+        Assert.equal(packet.frame.where.line, 3);
 
         // Remove the breakpoint.
         bpClient.remove(function (response) {
           gThreadClient.resume(function () {
             finishClient(gClient);
           });
         });
       });
--- a/devtools/server/tests/unit/test_conditional_breakpoint-02.js
+++ b/devtools/server/tests/unit/test_conditional_breakpoint-02.js
@@ -30,18 +30,18 @@ function test_simple_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let source = gThreadClient.source(packet.frame.where.source);
     source.setBreakpoint({
       line: 3,
       condition: "a === 2"
     }, function (response, bpClient) {
       gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(packet.why.type, "debuggerStatement");
-        do_check_eq(packet.frame.where.line, 4);
+        Assert.equal(packet.why.type, "debuggerStatement");
+        Assert.equal(packet.frame.where.line, 4);
 
         // Remove the breakpoint.
         bpClient.remove(function (response) {
           gThreadClient.resume(function () {
             finishClient(gClient);
           });
         });
       });
--- a/devtools/server/tests/unit/test_conditional_breakpoint-03.js
+++ b/devtools/server/tests/unit/test_conditional_breakpoint-03.js
@@ -30,18 +30,18 @@ function test_simple_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let source = gThreadClient.source(packet.frame.where.source);
     source.setBreakpoint({
       line: 3,
       condition: "throw new Error()"
     }, function (response, bpClient) {
       gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(packet.why.type, "breakpointConditionThrown");
-        do_check_eq(packet.frame.where.line, 3);
+        Assert.equal(packet.why.type, "breakpointConditionThrown");
+        Assert.equal(packet.frame.where.line, 3);
 
         // Remove the breakpoint.
         bpClient.remove(function (response) {
           gThreadClient.resume(function () {
             finishClient(gClient);
           });
         });
       });
--- a/devtools/server/tests/unit/test_dbgactor.js
+++ b/devtools/server/tests/unit/test_dbgactor.js
@@ -12,103 +12,103 @@ function run_test() {
   initTestDebuggerServer();
   gDebuggee = testGlobal("test-1");
   DebuggerServer.addTestGlobal(gDebuggee);
 
   let transport = DebuggerServer.connectPipe();
   gClient = new DebuggerClient(transport);
   gClient.addListener("connected", function (event, type, traits) {
     gClient.listTabs((response) => {
-      do_check_true("tabs" in response);
+      Assert.ok("tabs" in response);
       for (let tab of response.tabs) {
         if (tab.title == "test-1") {
           test_attach_tab(tab.actor);
           return false;
         }
       }
       // We should have found our tab in the list.
-      do_check_true(false);
+      Assert.ok(false);
       return undefined;
     });
   });
 
   gClient.connect();
 
   do_test_pending();
 }
 
 // Attach to |tabActor|, and check the response.
 function test_attach_tab(tabActor) {
   gClient.request({ to: tabActor, type: "attach" }, function (response) {
-    do_check_false("error" in response);
-    do_check_eq(response.from, tabActor);
-    do_check_eq(response.type, "tabAttached");
-    do_check_true(typeof response.threadActor === "string");
+    Assert.equal(false, "error" in response);
+    Assert.equal(response.from, tabActor);
+    Assert.equal(response.type, "tabAttached");
+    Assert.ok(typeof response.threadActor === "string");
 
     test_attach_thread(response.threadActor);
   });
 }
 
 // Attach to |threadActor|, check the response, and resume it.
 function test_attach_thread(threadActor) {
   gClient.request({ to: threadActor, type: "attach" }, function (response) {
-    do_check_false("error" in response);
-    do_check_eq(response.from, threadActor);
-    do_check_eq(response.type, "paused");
-    do_check_true("why" in response);
-    do_check_eq(response.why.type, "attached");
+    Assert.equal(false, "error" in response);
+    Assert.equal(response.from, threadActor);
+    Assert.equal(response.type, "paused");
+    Assert.ok("why" in response);
+    Assert.equal(response.why.type, "attached");
 
     test_resume_thread(threadActor);
   });
 }
 
 // Resume |threadActor|, and see that it stops at the 'debugger'
 // statement.
 function test_resume_thread(threadActor) {
   // Allow the client to resume execution.
   gClient.request({ to: threadActor, type: "resume" }, function (response) {
-    do_check_false("error" in response);
-    do_check_eq(response.from, threadActor);
-    do_check_eq(response.type, "resumed");
+    Assert.equal(false, "error" in response);
+    Assert.equal(response.from, threadActor);
+    Assert.equal(response.type, "resumed");
 
-    do_check_eq(xpcInspector.eventLoopNestLevel, 0);
+    Assert.equal(xpcInspector.eventLoopNestLevel, 0);
 
     // Now that we know we're resumed, we can make the debuggee do something.
     Cu.evalInSandbox("var a = true; var b = false; debugger; var b = true;", gDebuggee);
     // Now make sure that we've run the code after the debugger statement...
-    do_check_true(gDebuggee.b);
+    Assert.ok(gDebuggee.b);
   });
 
   gClient.addListener("paused", function (name, packet) {
-    do_check_eq(name, "paused");
-    do_check_false("error" in packet);
-    do_check_eq(packet.from, threadActor);
-    do_check_eq(packet.type, "paused");
-    do_check_true("actor" in packet);
-    do_check_true("why" in packet);
-    do_check_eq(packet.why.type, "debuggerStatement");
+    Assert.equal(name, "paused");
+    Assert.equal(false, "error" in packet);
+    Assert.equal(packet.from, threadActor);
+    Assert.equal(packet.type, "paused");
+    Assert.ok("actor" in packet);
+    Assert.ok("why" in packet);
+    Assert.equal(packet.why.type, "debuggerStatement");
 
     // Reach around the protocol to check that the debuggee is in the state
     // we expect.
-    do_check_true(gDebuggee.a);
-    do_check_false(gDebuggee.b);
+    Assert.ok(gDebuggee.a);
+    Assert.ok(!gDebuggee.b);
 
-    do_check_eq(xpcInspector.eventLoopNestLevel, 1);
+    Assert.equal(xpcInspector.eventLoopNestLevel, 1);
 
     // Let the debuggee continue execution.
     gClient.request({ to: threadActor, type: "resume" }, cleanup);
   });
 }
 
 function cleanup() {
   gClient.addListener("closed", function (event, result) {
     do_test_finished();
   });
 
   try {
     let inspector = Cc["@mozilla.org/jsinspector;1"].getService(Ci.nsIJSInspector);
-    do_check_eq(inspector.eventLoopNestLevel, 0);
+    Assert.equal(inspector.eventLoopNestLevel, 0);
   } catch (e) {
     dump(e);
   }
 
   gClient.close();
 }
--- a/devtools/server/tests/unit/test_dbgclient_debuggerstatement.js
+++ b/devtools/server/tests/unit/test_dbgclient_debuggerstatement.js
@@ -19,53 +19,53 @@ function run_test() {
       gTabClient = tabClient;
       test_threadAttach(reply.threadActor);
     });
   });
   do_test_pending();
 }
 
 function test_threadAttach(threadActorID) {
-  do_print("Trying to attach to thread " + threadActorID);
+  info("Trying to attach to thread " + threadActorID);
   gTabClient.attachThread({}, function (response, threadClient) {
-    do_check_eq(threadClient.state, "paused");
-    do_check_eq(threadClient.actor, threadActorID);
+    Assert.equal(threadClient.state, "paused");
+    Assert.equal(threadClient.actor, threadActorID);
     threadClient.resume(function () {
-      do_check_eq(threadClient.state, "attached");
+      Assert.equal(threadClient.state, "attached");
       test_debugger_statement(threadClient);
     });
   });
 }
 
 function test_debugger_statement(threadClient) {
   threadClient.addListener("paused", function (event, packet) {
-    do_check_eq(threadClient.state, "paused");
+    Assert.equal(threadClient.state, "paused");
     // Reach around the protocol to check that the debuggee is in the state
     // we expect.
-    do_check_true(gDebuggee.a);
-    do_check_false(gDebuggee.b);
+    Assert.ok(gDebuggee.a);
+    Assert.ok(!gDebuggee.b);
 
     let xpcInspector = Cc["@mozilla.org/jsinspector;1"].getService(Ci.nsIJSInspector);
-    do_check_eq(xpcInspector.eventLoopNestLevel, 1);
+    Assert.equal(xpcInspector.eventLoopNestLevel, 1);
 
     threadClient.resume(cleanup);
   });
 
   Cu.evalInSandbox("var a = true; var b = false; debugger; var b = true;", gDebuggee);
 
   // Now make sure that we've run the code after the debugger statement...
-  do_check_true(gDebuggee.b);
+  Assert.ok(gDebuggee.b);
 }
 
 function cleanup() {
   gClient.addListener("closed", function (event) {
     do_test_finished();
   });
 
   try {
     let xpcInspector = Cc["@mozilla.org/jsinspector;1"].getService(Ci.nsIJSInspector);
-    do_check_eq(xpcInspector.eventLoopNestLevel, 0);
+    Assert.equal(xpcInspector.eventLoopNestLevel, 0);
   } catch (e) {
     dump(e);
   }
 
   gClient.close();
 }
--- a/devtools/server/tests/unit/test_dbgglobal.js
+++ b/devtools/server/tests/unit/test_dbgglobal.js
@@ -25,27 +25,27 @@ function run_test() {
   // Now they should work.
   DebuggerServer.createListener();
   DebuggerServer.closeAllListeners();
 
   // Make sure we got the test's root actor all set up.
   let client1 = DebuggerServer.connectPipe();
   client1.hooks = {
     onPacket: function (packet1) {
-      do_check_eq(packet1.from, "root");
-      do_check_eq(packet1.applicationType, "xpcshell-tests");
+      Assert.equal(packet1.from, "root");
+      Assert.equal(packet1.applicationType, "xpcshell-tests");
 
       // Spin up a second connection, make sure it has its own root
       // actor.
       let client2 = DebuggerServer.connectPipe();
       client2.hooks = {
         onPacket: function (packet2) {
-          do_check_eq(packet2.from, "root");
-          do_check_neq(packet1.testConnectionPrefix,
-                       packet2.testConnectionPrefix);
+          Assert.equal(packet2.from, "root");
+          Assert.notEqual(packet1.testConnectionPrefix,
+                          packet2.testConnectionPrefix);
           client2.close();
         },
         onClosed: function (result) {
           client1.close();
         },
       };
       client2.ready();
     },
--- a/devtools/server/tests/unit/test_eval-01.js
+++ b/devtools/server/tests/unit/test_eval-01.js
@@ -25,28 +25,28 @@ function run_test() {
   });
   do_test_pending();
 }
 
 function test_simple_eval() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let arg1Actor = packet.frame.arguments[0].actor;
     gThreadClient.eval(null, "({ obj: true })", function (response) {
-      do_check_eq(response.type, "resumed");
+      Assert.equal(response.type, "resumed");
       // Expect a pause notification immediately.
       gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value...
-        do_check_eq(packet.type, "paused");
-        do_check_eq(packet.why.type, "clientEvaluated");
-        do_check_eq(packet.why.frameFinished.return.type, "object");
-        do_check_eq(packet.why.frameFinished.return.class, "Object");
+        Assert.equal(packet.type, "paused");
+        Assert.equal(packet.why.type, "clientEvaluated");
+        Assert.equal(packet.why.frameFinished.return.type, "object");
+        Assert.equal(packet.why.frameFinished.return.class, "Object");
 
         // Make sure the previous pause lifetime was correctly dropped.
         gClient.request({ to: arg1Actor, type: "bogusRequest" }, function (response) {
-          do_check_eq(response.error, "noSuchActor");
+          Assert.equal(response.error, "noSuchActor");
           gThreadClient.resume(function () {
             finishClient(gClient);
           });
         });
       });
     });
   });
 
--- a/devtools/server/tests/unit/test_eval-02.js
+++ b/devtools/server/tests/unit/test_eval-02.js
@@ -24,23 +24,23 @@ function run_test() {
                            });
   });
   do_test_pending();
 }
 
 function test_throw_eval() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     gThreadClient.eval(null, "throw 'failure'", function (response) {
-      do_check_eq(response.type, "resumed");
+      Assert.equal(response.type, "resumed");
       // Expect a pause notification immediately.
       gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value...
-        do_check_eq(packet.type, "paused");
-        do_check_eq(packet.why.type, "clientEvaluated");
-        do_check_eq(packet.why.frameFinished.throw, "failure");
+        Assert.equal(packet.type, "paused");
+        Assert.equal(packet.why.type, "clientEvaluated");
+        Assert.equal(packet.why.frameFinished.throw, "failure");
         gThreadClient.resume(function () {
           finishClient(gClient);
         });
       });
     });
   });
 
   /* eslint-disable */
--- a/devtools/server/tests/unit/test_eval-03.js
+++ b/devtools/server/tests/unit/test_eval-03.js
@@ -24,24 +24,24 @@ function run_test() {
                            });
   });
   do_test_pending();
 }
 
 function test_syntax_error_eval() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     gThreadClient.eval(null, "%$@!@#", function (response) {
-      do_check_eq(response.type, "resumed");
+      Assert.equal(response.type, "resumed");
       // Expect a pause notification immediately.
       gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value...
-        do_check_eq(packet.type, "paused");
-        do_check_eq(packet.why.type, "clientEvaluated");
-        do_check_eq(packet.why.frameFinished.throw.type, "object");
-        do_check_eq(packet.why.frameFinished.throw.class, "Error");
+        Assert.equal(packet.type, "paused");
+        Assert.equal(packet.why.type, "clientEvaluated");
+        Assert.equal(packet.why.frameFinished.throw.type, "object");
+        Assert.equal(packet.why.frameFinished.throw.class, "Error");
 
         gThreadClient.resume(function () {
           finishClient(gClient);
         });
       });
     });
   });
 
--- a/devtools/server/tests/unit/test_eval-04.js
+++ b/devtools/server/tests/unit/test_eval-04.js
@@ -29,29 +29,29 @@ function run_test() {
 function test_different_frames_eval() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     gThreadClient.getFrames(0, 2, function (response) {
       let frame0 = response.frames[0];
       let frame1 = response.frames[1];
 
       // Eval against the top frame...
       gThreadClient.eval(frame0.actor, "arg", function (response) {
-        do_check_eq(response.type, "resumed");
+        Assert.equal(response.type, "resumed");
         gThreadClient.addOneTimeListener("paused", function (event, packet) {
           // 'arg' should have been evaluated in frame0
-          do_check_eq(packet.type, "paused");
-          do_check_eq(packet.why.type, "clientEvaluated");
-          do_check_eq(packet.why.frameFinished.return, "arg0");
+          Assert.equal(packet.type, "paused");
+          Assert.equal(packet.why.type, "clientEvaluated");
+          Assert.equal(packet.why.frameFinished.return, "arg0");
 
           // Now eval against the second frame.
           gThreadClient.eval(frame1.actor, "arg", function (response) {
             gThreadClient.addOneTimeListener("paused", function (event, packet) {
               // 'arg' should have been evaluated in frame1
-              do_check_eq(packet.type, "paused");
-              do_check_eq(packet.why.frameFinished.return, "arg1");
+              Assert.equal(packet.type, "paused");
+              Assert.equal(packet.why.frameFinished.return, "arg1");
 
               gThreadClient.resume(function () {
                 finishClient(gClient);
               });
             });
           });
         });
       });
--- a/devtools/server/tests/unit/test_eval-05.js
+++ b/devtools/server/tests/unit/test_eval-05.js
@@ -25,25 +25,25 @@ function run_test() {
   });
   do_test_pending();
 }
 
 function test_pauses_eval() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     gThreadClient.eval(null, "debugger", function (response) {
       // Expect a resume then a debuggerStatement pause.
-      do_check_eq(response.type, "resumed");
+      Assert.equal(response.type, "resumed");
       gThreadClient.addOneTimeListener("paused", function (event, packet) {
-        do_check_eq(packet.why.type, "debuggerStatement");
+        Assert.equal(packet.why.type, "debuggerStatement");
         // Resume from the debugger statement should immediately re-pause
         // with a clientEvaluated reason.
         gThreadClient.resume(function (packet) {
-          do_check_eq(packet.type, "resumed");
+          Assert.equal(packet.type, "resumed");
           gThreadClient.addOneTimeListener("paused", function (event, packet) {
-            do_check_eq(packet.why.type, "clientEvaluated");
+            Assert.equal(packet.why.type, "clientEvaluated");
             gThreadClient.resume(function () {
               finishClient(gClient);
             });
           });
         });
       });
     });
   });
--- a/devtools/server/tests/unit/test_eventlooplag_actor.js
+++ b/devtools/server/tests/unit/test_eventlooplag_actor.js
@@ -20,19 +20,19 @@ function run_test() {
   let front;
   let client = new DebuggerClient(DebuggerServer.connectPipe());
 
   // Start tracking event loop lags.
   client.connect().then(function () {
     client.listTabs(function (resp) {
       front = new EventLoopLagFront(client, resp);
       front.start().then(success => {
-        do_check_true(success);
+        Assert.ok(success);
         front.once("event-loop-lag", gotLagEvent);
-        do_execute_soon(lag);
+        executeSoon(lag);
       });
     });
   });
 
   // Force a lag
   function lag() {
     let start = new Date();
     let duration = threshold + interval + 1;
@@ -41,17 +41,17 @@ function run_test() {
         break;
       }
     }
   }
 
   // Got a lag event. The test will time out if the actor
   // fails to detect the lag.
   function gotLagEvent(time) {
-    do_print("lag: " + time);
-    do_check_true(time >= threshold);
+    info("lag: " + time);
+    Assert.ok(time >= threshold);
     front.stop().then(() => {
       finishClient(client);
     });
   }
 
   do_test_pending();
 }
--- a/devtools/server/tests/unit/test_forwardingprefix.js
+++ b/devtools/server/tests/unit/test_forwardingprefix.js
@@ -83,25 +83,25 @@ function tryActors(reachables, completed
 
     count++;
 
     // phone home
     gClient.request(
       { to: actor, type: "echo", value: "tango"},
       (response) => {
         if (reachables.has(actor)) {
-          do_check_matches({ from: actor, to: actor,
+          Assert.deepEqual({ from: actor, to: actor,
                              type: "echo", value: "tango" }, response);
         } else {
-          do_check_matches({ from: actor, error: "noSuchActor",
+          Assert.deepEqual({ from: actor, error: "noSuchActor",
                              message: "No such actor for ID: " + actor }, response);
         }
 
         if (--count == 0) {
-          do_execute_soon(completed, "tryActors callback " + completed.name);
+          executeSoon(completed, "tryActors callback " + completed.name);
         }
       });
   }
 }
 
 /*
  * With no forwarding established, sending messages to root should work,
  * but sending messages to prefixed actor names, or anyone else, should get
--- a/devtools/server/tests/unit/test_frameactor-01.js
+++ b/devtools/server/tests/unit/test_frameactor-01.js
@@ -22,19 +22,19 @@ function run_test() {
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
-    do_check_true(!!packet.frame);
-    do_check_true(!!packet.frame.actor);
-    do_check_eq(packet.frame.callee.name, "stopMe");
+    Assert.ok(!!packet.frame);
+    Assert.ok(!!packet.frame.actor);
+    Assert.equal(packet.frame.callee.name, "stopMe");
     gThreadClient.resume(function () {
       finishClient(gClient);
     });
   });
 
   gDebuggee.eval("(" + function () {
     function stopMe() {
       debugger;
--- a/devtools/server/tests/unit/test_frameactor-02.js
+++ b/devtools/server/tests/unit/test_frameactor-02.js
@@ -24,17 +24,17 @@ function run_test() {
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
   gThreadClient.addOneTimeListener("paused", function (event, packet1) {
     gThreadClient.addOneTimeListener("paused", function (event, packet2) {
-      do_check_eq(packet1.frame.actor, packet2.frame.actor);
+      Assert.equal(packet1.frame.actor, packet2.frame.actor);
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
     gThreadClient.resume();
   });
 
   gDebuggee.eval("(" + function () {
--- a/devtools/server/tests/unit/test_frameactor-03.js
+++ b/devtools/server/tests/unit/test_frameactor-03.js
@@ -25,18 +25,18 @@ function run_test() {
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
   gThreadClient.addOneTimeListener("paused", function (event, packet1) {
     gThreadClient.addOneTimeListener("paused", function (event, packet2) {
       let poppedFrames = packet2.poppedFrames;
-      do_check_eq(typeof (poppedFrames), typeof ([]));
-      do_check_true(poppedFrames.indexOf(packet1.frame.actor) >= 0);
+      Assert.equal(typeof (poppedFrames), typeof ([]));
+      Assert.ok(poppedFrames.indexOf(packet1.frame.actor) >= 0);
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
     gThreadClient.resume();
   });
 
   gDebuggee.eval("(" + function () {
--- a/devtools/server/tests/unit/test_frameactor-04.js
+++ b/devtools/server/tests/unit/test_frameactor-04.js
@@ -51,27 +51,27 @@ function test_frame_slice() {
     gThreadClient.resume(() => finishClient(gClient));
     return;
   }
 
   let test = gSliceTests.shift();
   gThreadClient.getFrames(test.start, test.count, function (response) {
     let testFrames = gFrames.slice(test.start,
                                    test.count ? test.start + test.count : undefined);
-    do_check_eq(testFrames.length, response.frames.length);
+    Assert.equal(testFrames.length, response.frames.length);
     for (let i = 0; i < testFrames.length; i++) {
       let expected = testFrames[i];
       let actual = response.frames[i];
 
       if (test.resetActors) {
         expected.actor = actual.actor;
       }
 
       for (let key of ["type", "callee-name"]) {
-        do_check_eq(expected[key] || undefined, actual[key]);
+        Assert.equal(expected[key] || undefined, actual[key]);
       }
     }
     test_frame_slice();
   });
 }
 
 function test_pause_frame() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
--- a/devtools/server/tests/unit/test_frameactor-05.js
+++ b/devtools/server/tests/unit/test_frameactor-05.js
@@ -25,27 +25,27 @@ function run_test() {
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     gThreadClient.getFrames(0, null, function (frameResponse) {
-      do_check_eq(frameResponse.frames.length, 5);
+      Assert.equal(frameResponse.frames.length, 5);
       // Now wait for the next pause, after which the three
       // youngest actors should be popped..
       let expectPopped = frameResponse.frames.slice(0, 3).map(frame => frame.actor);
       expectPopped.sort();
 
       gThreadClient.addOneTimeListener("paused", function (event, pausePacket) {
         let popped = pausePacket.poppedFrames.sort();
-        do_check_eq(popped.length, 3);
+        Assert.equal(popped.length, 3);
         for (let i = 0; i < 3; i++) {
-          do_check_eq(expectPopped[i], popped[i]);
+          Assert.equal(expectPopped[i], popped[i]);
         }
 
         gThreadClient.resume(() => finishClient(gClient));
       });
       gThreadClient.resume();
     });
   });
 
--- a/devtools/server/tests/unit/test_frameactor_wasm-01.js
+++ b/devtools/server/tests/unit/test_frameactor_wasm-01.js
@@ -22,37 +22,37 @@ function run_test() {
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
     attachTestTabAndResume(
       gClient, "test-stack",
       function (response, tabClient, threadClient) {
         gThreadClient = threadClient;
         gThreadClient.reconfigure({ observeAsmJS: true }, function (response) {
-          do_check_eq(!!response.error, false);
+          Assert.equal(!!response.error, false);
           test_pause_frame();
         });
       });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     gThreadClient.getFrames(0, null, function (frameResponse) {
-      do_check_eq(frameResponse.frames.length, 4);
+      Assert.equal(frameResponse.frames.length, 4);
 
       let wasmFrame = frameResponse.frames[1];
-      do_check_eq(wasmFrame.type, "wasmcall");
-      do_check_eq(wasmFrame.this, undefined);
+      Assert.equal(wasmFrame.type, "wasmcall");
+      Assert.equal(wasmFrame.this, undefined);
 
       let location = wasmFrame.where;
-      do_check_eq(location.line > 0, true);
-      do_check_eq(location.column > 0, true);
-      do_check_eq(/^wasm:(?:[^:]*:)*?[0-9a-f]{16}$/.test(location.source.url), true);
+      Assert.equal(location.line > 0, true);
+      Assert.equal(location.column > 0, true);
+      Assert.equal(/^wasm:(?:[^:]*:)*?[0-9a-f]{16}$/.test(location.source.url), true);
 
       finishClient(gClient);
     });
   });
 
   /* eslint-disable comma-spacing, max-len */
   gDebuggee.eval("(" + function () {
     // WebAssembly bytecode was generated by running:
--- a/devtools/server/tests/unit/test_framearguments-01.js
+++ b/devtools/server/tests/unit/test_framearguments-01.js
@@ -23,25 +23,25 @@ function run_test() {
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let args = packet.frame.arguments;
-    do_check_eq(args.length, 6);
-    do_check_eq(args[0], 42);
-    do_check_eq(args[1], true);
-    do_check_eq(args[2], "nasu");
-    do_check_eq(args[3].type, "null");
-    do_check_eq(args[4].type, "undefined");
-    do_check_eq(args[5].type, "object");
-    do_check_eq(args[5].class, "Object");
-    do_check_true(!!args[5].actor);
+    Assert.equal(args.length, 6);
+    Assert.equal(args[0], 42);
+    Assert.equal(args[1], true);
+    Assert.equal(args[2], "nasu");
+    Assert.equal(args[3].type, "null");
+    Assert.equal(args[4].type, "undefined");
+    Assert.equal(args[5].type, "object");
+    Assert.equal(args[5].class, "Object");
+    Assert.ok(!!args[5].actor);
 
     gThreadClient.resume(function () {
       finishClient(gClient);
     });
   });
 
   gDebuggee.eval("(" + function () {
     function stopMe(number, bool, string, null_, undef, object) {
--- a/devtools/server/tests/unit/test_framebindings-01.js
+++ b/devtools/server/tests/unit/test_framebindings-01.js
@@ -26,44 +26,44 @@ function run_test() {
 }
 
 function test_pause_frame() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let bindings = packet.frame.environment.bindings;
     let args = bindings.arguments;
     let vars = bindings.variables;
 
-    do_check_eq(args.length, 6);
-    do_check_eq(args[0].number.value, 42);
-    do_check_eq(args[1].bool.value, true);
-    do_check_eq(args[2].string.value, "nasu");
-    do_check_eq(args[3].null_.value.type, "null");
-    do_check_eq(args[4].undef.value.type, "undefined");
-    do_check_eq(args[5].object.value.type, "object");
-    do_check_eq(args[5].object.value.class, "Object");
-    do_check_true(!!args[5].object.value.actor);
+    Assert.equal(args.length, 6);
+    Assert.equal(args[0].number.value, 42);
+    Assert.equal(args[1].bool.value, true);
+    Assert.equal(args[2].string.value, "nasu");
+    Assert.equal(args[3].null_.value.type, "null");
+    Assert.equal(args[4].undef.value.type, "undefined");
+    Assert.equal(args[5].object.value.type, "object");
+    Assert.equal(args[5].object.value.class, "Object");
+    Assert.ok(!!args[5].object.value.actor);
 
-    do_check_eq(vars.a.value, 1);
-    do_check_eq(vars.b.value, true);
-    do_check_eq(vars.c.value.type, "object");
-    do_check_eq(vars.c.value.class, "Object");
-    do_check_true(!!vars.c.value.actor);
+    Assert.equal(vars.a.value, 1);
+    Assert.equal(vars.b.value, true);
+    Assert.equal(vars.c.value.type, "object");
+    Assert.equal(vars.c.value.class, "Object");
+    Assert.ok(!!vars.c.value.actor);
 
     let objClient = gThreadClient.pauseGrip(vars.c.value);
     objClient.getPrototypeAndProperties(function (response) {
-      do_check_eq(response.ownProperties.a.configurable, true);
-      do_check_eq(response.ownProperties.a.enumerable, true);
-      do_check_eq(response.ownProperties.a.writable, true);
-      do_check_eq(response.ownProperties.a.value, "a");
+      Assert.equal(response.ownProperties.a.configurable, true);
+      Assert.equal(response.ownProperties.a.enumerable, true);
+      Assert.equal(response.ownProperties.a.writable, true);
+      Assert.equal(response.ownProperties.a.value, "a");
 
-      do_check_eq(response.ownProperties.b.configurable, true);
-      do_check_eq(response.ownProperties.b.enumerable, true);
-      do_check_eq(response.ownProperties.b.writable, true);
-      do_check_eq(response.ownProperties.b.value.type, "undefined");
-      do_check_false("class" in response.ownProperties.b.value);
+      Assert.equal(response.ownProperties.b.configurable, true);
+      Assert.equal(response.ownProperties.b.enumerable, true);
+      Assert.equal(response.ownProperties.b.writable, true);
+      Assert.equal(response.ownProperties.b.value.type, "undefined");
+      Assert.equal(false, "class" in response.ownProperties.b.value);
 
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
   });
 
   /* eslint-disable */
--- a/devtools/server/tests/unit/test_framebindings-02.js
+++ b/devtools/server/tests/unit/test_framebindings-02.js
@@ -26,30 +26,30 @@ function run_test() {
 }
 
 function test_pause_frame() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let parentEnv = packet.frame.environment.parent;
     let bindings = parentEnv.bindings;
     let args = bindings.arguments;
     let vars = bindings.variables;
-    do_check_neq(parentEnv, undefined);
-    do_check_eq(args.length, 0);
-    do_check_eq(vars.stopMe.value.type, "object");
-    do_check_eq(vars.stopMe.value.class, "Function");
-    do_check_true(!!vars.stopMe.value.actor);
+    Assert.notEqual(parentEnv, undefined);
+    Assert.equal(args.length, 0);
+    Assert.equal(vars.stopMe.value.type, "object");
+    Assert.equal(vars.stopMe.value.class, "Function");
+    Assert.ok(!!vars.stopMe.value.actor);
 
     // Skip the global lexical scope.
     parentEnv = parentEnv.parent.parent;
-    do_check_neq(parentEnv, undefined);
+    Assert.notEqual(parentEnv, undefined);
     let objClient = gThreadClient.pauseGrip(parentEnv.object);
     objClient.getPrototypeAndProperties(function (response) {
-      do_check_eq(response.ownProperties.Object.value.type, "object");
-      do_check_eq(response.ownProperties.Object.value.class, "Function");
-      do_check_true(!!response.ownProperties.Object.value.actor);
+      Assert.equal(response.ownProperties.Object.value.type, "object");
+      Assert.equal(response.ownProperties.Object.value.class, "Function");
+      Assert.ok(!!response.ownProperties.Object.value.actor);
 
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
   });
 
   /* eslint-disable */
--- a/devtools/server/tests/unit/test_framebindings-03.js
+++ b/devtools/server/tests/unit/test_framebindings-03.js
@@ -24,37 +24,37 @@ function run_test() {
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let env = packet.frame.environment;
-    do_check_neq(env, undefined);
+    Assert.notEqual(env, undefined);
 
     let parentEnv = env.parent;
-    do_check_neq(parentEnv, undefined);
+    Assert.notEqual(parentEnv, undefined);
 
     let bindings = parentEnv.bindings;
     let args = bindings.arguments;
     let vars = bindings.variables;
-    do_check_eq(args.length, 1);
-    do_check_eq(args[0].number.value, 10);
-    do_check_eq(vars.r.value, 10);
-    do_check_eq(vars.a.value, Math.PI * 100);
-    do_check_eq(vars.arguments.value.class, "Arguments");
-    do_check_true(!!vars.arguments.value.actor);
+    Assert.equal(args.length, 1);
+    Assert.equal(args[0].number.value, 10);
+    Assert.equal(vars.r.value, 10);
+    Assert.equal(vars.a.value, Math.PI * 100);
+    Assert.equal(vars.arguments.value.class, "Arguments");
+    Assert.ok(!!vars.arguments.value.actor);
 
     let objClient = gThreadClient.pauseGrip(env.object);
     objClient.getPrototypeAndProperties(function (response) {
-      do_check_eq(response.ownProperties.PI.value, Math.PI);
-      do_check_eq(response.ownProperties.cos.value.type, "object");
-      do_check_eq(response.ownProperties.cos.value.class, "Function");
-      do_check_true(!!response.ownProperties.cos.value.actor);
+      Assert.equal(response.ownProperties.PI.value, Math.PI);
+      Assert.equal(response.ownProperties.cos.value.type, "object");
+      Assert.equal(response.ownProperties.cos.value.class, "Function");
+      Assert.ok(!!response.ownProperties.cos.value.actor);
 
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
   });
 
   /* eslint-disable */
--- a/devtools/server/tests/unit/test_framebindings-04.js
+++ b/devtools/server/tests/unit/test_framebindings-04.js
@@ -25,47 +25,47 @@ function run_test() {
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let env = packet.frame.environment;
-    do_check_neq(env, undefined);
+    Assert.notEqual(env, undefined);
 
     let objClient = gThreadClient.pauseGrip(env.object);
     objClient.getPrototypeAndProperties(function (response) {
-      do_check_eq(response.ownProperties.one.value, 1);
-      do_check_eq(response.ownProperties.two.value, 2);
-      do_check_eq(response.ownProperties.foo, undefined);
+      Assert.equal(response.ownProperties.one.value, 1);
+      Assert.equal(response.ownProperties.two.value, 2);
+      Assert.equal(response.ownProperties.foo, undefined);
 
       let parentEnv = env.parent;
-      do_check_neq(parentEnv, undefined);
+      Assert.notEqual(parentEnv, undefined);
 
       let parentClient = gThreadClient.pauseGrip(parentEnv.object);
       parentClient.getPrototypeAndProperties(function (response) {
-        do_check_eq(response.ownProperties.PI.value, Math.PI);
-        do_check_eq(response.ownProperties.cos.value.type, "object");
-        do_check_eq(response.ownProperties.cos.value.class, "Function");
-        do_check_true(!!response.ownProperties.cos.value.actor);
+        Assert.equal(response.ownProperties.PI.value, Math.PI);
+        Assert.equal(response.ownProperties.cos.value.type, "object");
+        Assert.equal(response.ownProperties.cos.value.class, "Function");
+        Assert.ok(!!response.ownProperties.cos.value.actor);
 
         parentEnv = parentEnv.parent;
-        do_check_neq(parentEnv, undefined);
+        Assert.notEqual(parentEnv, undefined);
 
         let bindings = parentEnv.bindings;
         let args = bindings.arguments;
         let vars = bindings.variables;
-        do_check_eq(args.length, 1);
-        do_check_eq(args[0].number.value, 10);
-        do_check_eq(vars.r.value, 10);
-        do_check_eq(vars.a.value, Math.PI * 100);
-        do_check_eq(vars.arguments.value.class, "Arguments");
-        do_check_true(!!vars.arguments.value.actor);
-        do_check_eq(vars.foo.value, 2 * Math.PI);
+        Assert.equal(args.length, 1);
+        Assert.equal(args[0].number.value, 10);
+        Assert.equal(vars.r.value, 10);
+        Assert.equal(vars.a.value, Math.PI * 100);
+        Assert.equal(vars.arguments.value.class, "Arguments");
+        Assert.ok(!!vars.arguments.value.actor);
+        Assert.equal(vars.foo.value, 2 * Math.PI);
 
         gThreadClient.resume(function () {
           finishClient(gClient);
         });
       });
     });
   });
 
--- a/devtools/server/tests/unit/test_framebindings-05.js
+++ b/devtools/server/tests/unit/test_framebindings-05.js
@@ -24,36 +24,36 @@ function run_test() {
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let env = packet.frame.environment;
-    do_check_neq(env, undefined);
+    Assert.notEqual(env, undefined);
 
     let objClient = gThreadClient.pauseGrip(env.object);
     objClient.getPrototypeAndProperties(function (response) {
-      do_check_eq(response.ownProperties.PI.value, Math.PI);
-      do_check_eq(response.ownProperties.cos.value.type, "object");
-      do_check_eq(response.ownProperties.cos.value.class, "Function");
-      do_check_true(!!response.ownProperties.cos.value.actor);
+      Assert.equal(response.ownProperties.PI.value, Math.PI);
+      Assert.equal(response.ownProperties.cos.value.type, "object");
+      Assert.equal(response.ownProperties.cos.value.class, "Function");
+      Assert.ok(!!response.ownProperties.cos.value.actor);
 
       // Skip the global lexical scope.
       let parentEnv = env.parent.parent;
-      do_check_neq(parentEnv, undefined);
+      Assert.notEqual(parentEnv, undefined);
 
       let parentClient = gThreadClient.pauseGrip(parentEnv.object);
       parentClient.getPrototypeAndProperties(function (response) {
-        do_check_eq(response.ownProperties.a.value, Math.PI * 100);
-        do_check_eq(response.ownProperties.r.value, 10);
-        do_check_eq(response.ownProperties.Object.value.type, "object");
-        do_check_eq(response.ownProperties.Object.value.class, "Function");
-        do_check_true(!!response.ownProperties.Object.value.actor);
+        Assert.equal(response.ownProperties.a.value, Math.PI * 100);
+        Assert.equal(response.ownProperties.r.value, 10);
+        Assert.equal(response.ownProperties.Object.value.type, "object");
+        Assert.equal(response.ownProperties.Object.value.class, "Function");
+        Assert.ok(!!response.ownProperties.Object.value.actor);
 
         gThreadClient.resume(function () {
           finishClient(gClient);
         });
       });
     });
   });
 
--- a/devtools/server/tests/unit/test_framebindings-07.js
+++ b/devtools/server/tests/unit/test_framebindings-07.js
@@ -22,35 +22,35 @@ function run_test() {
                            });
   });
   do_test_pending();
 }
 
 function test_banana_environment() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let environment = packet.frame.environment;
-    do_check_eq(environment.type, "function");
+    Assert.equal(environment.type, "function");
 
     let parent = environment.parent;
-    do_check_eq(parent.type, "block");
+    Assert.equal(parent.type, "block");
 
     let grandpa = parent.parent;
-    do_check_eq(grandpa.type, "function");
+    Assert.equal(grandpa.type, "function");
 
     let envClient = gThreadClient.environment(environment);
     envClient.getBindings(response => {
-      do_check_eq(response.bindings.arguments[0].z.value, "z");
+      Assert.equal(response.bindings.arguments[0].z.value, "z");
 
       let parentClient = gThreadClient.environment(parent);
       parentClient.getBindings(response => {
-        do_check_eq(response.bindings.variables.banana3.value.class, "Function");
+        Assert.equal(response.bindings.variables.banana3.value.class, "Function");
 
         let grandpaClient = gThreadClient.environment(grandpa);
         grandpaClient.getBindings(response => {
-          do_check_eq(response.bindings.arguments[0].y.value, "y");
+          Assert.equal(response.bindings.arguments[0].y.value, "y");
           gThreadClient.resume(() => finishClient(gClient));
         });
       });
     });
   });
 
   gDebuggee.eval("function banana(x) {\n" +
                  "  return function banana2(y) {\n" +
--- a/devtools/server/tests/unit/test_frameclient-01.js
+++ b/devtools/server/tests/unit/test_frameclient-01.js
@@ -20,30 +20,30 @@ function run_test() {
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     gThreadClient.addOneTimeListener("framesadded", function () {
-      do_check_eq(gThreadClient.cachedFrames.length, 3);
-      do_check_true(gThreadClient.moreFrames);
-      do_check_false(gThreadClient.fillFrames(3));
+      Assert.equal(gThreadClient.cachedFrames.length, 3);
+      Assert.ok(gThreadClient.moreFrames);
+      Assert.ok(!gThreadClient.fillFrames(3));
 
-      do_check_true(gThreadClient.fillFrames(30));
+      Assert.ok(gThreadClient.fillFrames(30));
       gThreadClient.addOneTimeListener("framesadded", function () {
-        do_check_false(gThreadClient.moreFrames);
-        do_check_eq(gThreadClient.cachedFrames.length, 7);
+        Assert.ok(!gThreadClient.moreFrames);
+        Assert.equal(gThreadClient.cachedFrames.length, 7);
         gThreadClient.resume(function () {
           finishClient(gClient);
         });
       });
     });
-    do_check_true(gThreadClient.fillFrames(3));
+    Assert.ok(gThreadClient.fillFrames(3));
   });
 
   /* eslint-disable */
   gDebuggee.eval("(" + function () {
     var recurseLeft = 5;
     function recurse() {
       if (--recurseLeft == 0) {
         debugger;
--- a/devtools/server/tests/unit/test_frameclient-02.js
+++ b/devtools/server/tests/unit/test_frameclient-02.js
@@ -20,22 +20,22 @@ function run_test() {
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     // Ask for exactly the number of frames we expect.
     gThreadClient.addOneTimeListener("framesadded", function () {
-      do_check_false(gThreadClient.moreFrames);
+      Assert.ok(!gThreadClient.moreFrames);
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
-    do_check_true(gThreadClient.fillFrames(3));
+    Assert.ok(gThreadClient.fillFrames(3));
   });
 
   /* eslint-disable */
   gDebuggee.eval("(" + function () {
     var recurseLeft = 1;
     function recurse() {
       if (--recurseLeft == 0) {
         debugger;
--- a/devtools/server/tests/unit/test_functiongrips-01.js
+++ b/devtools/server/tests/unit/test_functiongrips-01.js
@@ -24,70 +24,70 @@ function run_test() {
   });
   do_test_pending();
 }
 
 function test_named_function() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let args = packet.frame.arguments;
 
-    do_check_eq(args[0].class, "Function");
-    do_check_eq(args[0].name, "stopMe");
-    do_check_eq(args[0].displayName, "stopMe");
+    Assert.equal(args[0].class, "Function");
+    Assert.equal(args[0].name, "stopMe");
+    Assert.equal(args[0].displayName, "stopMe");
 
     let objClient = gThreadClient.pauseGrip(args[0]);
     objClient.getParameterNames(function (response) {
-      do_check_eq(response.parameterNames.length, 1);
-      do_check_eq(response.parameterNames[0], "arg1");
+      Assert.equal(response.parameterNames.length, 1);
+      Assert.equal(response.parameterNames[0], "arg1");
 
       gThreadClient.resume(test_inferred_name_function);
     });
   });
 
   gDebuggee.eval("stopMe(stopMe)");
 }
 
 function test_inferred_name_function() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let args = packet.frame.arguments;
 
-    do_check_eq(args[0].class, "Function");
+    Assert.equal(args[0].class, "Function");
     // No name for an anonymous function, but it should have an inferred name.
-    do_check_eq(args[0].name, undefined);
-    do_check_eq(args[0].displayName, "m");
+    Assert.equal(args[0].name, undefined);
+    Assert.equal(args[0].displayName, "m");
 
     let objClient = gThreadClient.pauseGrip(args[0]);
     objClient.getParameterNames(function (response) {
-      do_check_eq(response.parameterNames.length, 3);
-      do_check_eq(response.parameterNames[0], "foo");
-      do_check_eq(response.parameterNames[1], "bar");
-      do_check_eq(response.parameterNames[2], "baz");
+      Assert.equal(response.parameterNames.length, 3);
+      Assert.equal(response.parameterNames[0], "foo");
+      Assert.equal(response.parameterNames[1], "bar");
+      Assert.equal(response.parameterNames[2], "baz");
 
       gThreadClient.resume(test_anonymous_function);
     });
   });
 
   gDebuggee.eval("var o = { m: function(foo, bar, baz) { } }; stopMe(o.m)");
 }
 
 function test_anonymous_function() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let args = packet.frame.arguments;
 
-    do_check_eq(args[0].class, "Function");
+    Assert.equal(args[0].class, "Function");
     // No name for an anonymous function, and no inferred name, either.
-    do_check_eq(args[0].name, undefined);
-    do_check_eq(args[0].displayName, undefined);
+    Assert.equal(args[0].name, undefined);
+    Assert.equal(args[0].displayName, undefined);
 
     let objClient = gThreadClient.pauseGrip(args[0]);
     objClient.getParameterNames(function (response) {
-      do_check_eq(response.parameterNames.length, 3);
-      do_check_eq(response.parameterNames[0], "foo");
-      do_check_eq(response.parameterNames[1], "bar");
-      do_check_eq(response.parameterNames[2], "baz");
+      Assert.equal(response.parameterNames.length, 3);
+      Assert.equal(response.parameterNames[0], "foo");
+      Assert.equal(response.parameterNames[1], "bar");
+      Assert.equal(response.parameterNames[2], "baz");
 
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
   });
 
   gDebuggee.eval("stopMe(function(foo, bar, baz) { })");
--- a/devtools/server/tests/unit/test_get-executable-lines-source-map.js
+++ b/devtools/server/tests/unit/test_get-executable-lines-source-map.js
@@ -29,23 +29,23 @@ function run_test() {
     );
   });
 
   do_test_pending();
 }
 
 function test_executable_lines() {
   gThreadClient.addOneTimeListener("newSource", function _onNewSource(evt, packet) {
-    do_check_eq(evt, "newSource");
+    Assert.equal(evt, "newSource");
 
     gThreadClient.getSources(function ({error, sources}) {
-      do_check_true(!error);
+      Assert.ok(!error);
       let source = gThreadClient.source(sources[0]);
       source.getExecutableLines(function (lines) {
-        do_check_true(arrays_equal([1, 2, 4, 6], lines));
+        Assert.ok(arrays_equal([1, 2, 4, 6], lines));
         finishClient(gClient);
       });
     });
   });
 
   let code = readFile("sourcemapped.js") + "\n//# sourceMappingURL=" +
     getFileUrl("source-map-data/sourcemapped.map");
 
--- a/devtools/server/tests/unit/test_get-executable-lines.js
+++ b/devtools/server/tests/unit/test_get-executable-lines.js
@@ -29,23 +29,23 @@ function run_test() {
     );
   });
 
   do_test_pending();
 }
 
 function test_executable_lines() {
   gThreadClient.addOneTimeListener("newSource", function _onNewSource(evt, packet) {
-    do_check_eq(evt, "newSource");
+    Assert.equal(evt, "newSource");
 
     gThreadClient.getSources(function ({error, sources}) {
-      do_check_true(!error);
+      Assert.ok(!error);
       let source = gThreadClient.source(sources[0]);
       source.getExecutableLines(function (lines) {
-        do_check_true(arrays_equal([2, 5, 7, 8, 10, 12, 14, 16, 17], lines));
+        Assert.ok(arrays_equal([2, 5, 7, 8, 10, 12, 14, 16, 17], lines));
         finishClient(gClient);
       });
     });
   });
 
   let code = readFile("sourcemapped.js");
 
   Components.utils.evalInSandbox(code, gDebuggee, "1.8",
--- a/devtools/server/tests/unit/test_getRuleText.js
+++ b/devtools/server/tests/unit/test_getRuleText.js
@@ -107,32 +107,32 @@ const TEST_DATA = [
     line: 1,
     column: 1,
     expected: {offset: 4, text: ""}
   },
 ];
 
 function run_test() {
   for (let test of TEST_DATA) {
-    do_print("Starting test: " + test.desc);
-    do_print("Input string " + test.input);
+    info("Starting test: " + test.desc);
+    info("Input string " + test.input);
     let output;
     try {
       output = getRuleText(test.input, test.line, test.column);
       if (test.throws) {
-        do_print("Test should have thrown");
-        do_check_true(false);
+        info("Test should have thrown");
+        Assert.ok(false);
       }
     } catch (e) {
-      do_print("getRuleText threw an exception with the given input string");
+      info("getRuleText threw an exception with the given input string");
       if (test.throws) {
-        do_print("Exception expected");
-        do_check_true(true);
+        info("Exception expected");
+        Assert.ok(true);
       } else {
-        do_print("Exception unexpected\n" + e);
-        do_check_true(false);
+        info("Exception unexpected\n" + e);
+        Assert.ok(false);
       }
     }
     if (output) {
       deepEqual(output, test.expected);
     }
   }
 }
--- a/devtools/server/tests/unit/test_getTextAtLineColumn.js
+++ b/devtools/server/tests/unit/test_getTextAtLineColumn.js
@@ -21,15 +21,15 @@ const TEST_DATA = [
     line: 3,
     column: 3,
     expected: {offset: 11, text: "three"}
   },
 ];
 
 function run_test() {
   for (let test of TEST_DATA) {
-    do_print("Starting test: " + test.desc);
-    do_print("Input string " + test.input);
+    info("Starting test: " + test.desc);
+    info("Input string " + test.input);
 
     let output = getTextAtLineColumn(test.input, test.line, test.column);
     deepEqual(output, test.expected);
   }
 }
--- a/devtools/server/tests/unit/test_getyoungestframe.js
+++ b/devtools/server/tests/unit/test_getyoungestframe.js
@@ -5,23 +5,23 @@ function run_test() {
   let xpcInspector = Cc["@mozilla.org/jsinspector;1"].getService(Ci.nsIJSInspector);
   let g = testGlobal("test1");
 
   let dbg = new Debugger();
   dbg.uncaughtExceptionHook = testExceptionHook;
 
   dbg.addDebuggee(g);
   dbg.onDebuggerStatement = function (frame) {
-    do_check_true(frame === dbg.getNewestFrame());
+    Assert.ok(frame === dbg.getNewestFrame());
     // Execute from the nested event loop, dbg.getNewestFrame() won't
     // be working anymore.
 
-    do_execute_soon(function () {
+    executeSoon(function () {
       try {
-        do_check_true(frame === dbg.getNewestFrame());
+        Assert.ok(frame === dbg.getNewestFrame());
       } finally {
         xpcInspector.exitNestedEventLoop("test");
       }
     });
     xpcInspector.enterNestedEventLoop("test");
   };
 
   g.eval("function debuggerStatement() { debugger; }; debuggerStatement();");
--- a/devtools/server/tests/unit/test_ignore_caught_exceptions.js
+++ b/devtools/server/tests/unit/test_ignore_caught_exceptions.js
@@ -25,18 +25,18 @@ function run_test() {
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     gThreadClient.addOneTimeListener("paused", function (event, packet) {
-      do_check_eq(packet.why.type, "exception");
-      do_check_eq(packet.why.exception, "bar");
+      Assert.equal(packet.why.type, "exception");
+      Assert.equal(packet.why.exception, "bar");
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
     gThreadClient.pauseOnExceptions(true, true);
     gThreadClient.resume();
   });
 
--- a/devtools/server/tests/unit/test_ignore_no_interface_exceptions.js
+++ b/devtools/server/tests/unit/test_ignore_no_interface_exceptions.js
@@ -24,18 +24,18 @@ function run_test() {
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
   gThreadClient.pauseOnExceptions(true, false, function () {
     gThreadClient.addOneTimeListener("paused", function (event, packet) {
-      do_check_eq(packet.why.type, "exception");
-      do_check_eq(packet.why.exception, 42);
+      Assert.equal(packet.why.type, "exception");
+      Assert.equal(packet.why.exception, 42);
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
 
     /* eslint-disable */
     gDebuggee.eval("(" + function () {
       function QueryInterface() {
--- a/devtools/server/tests/unit/test_interrupt.js
+++ b/devtools/server/tests/unit/test_interrupt.js
@@ -17,29 +17,29 @@ function run_test() {
   gClient.connect().then(function (type, traits) {
     attachTestTab(gClient, "test-1", test_attach);
   });
   do_test_pending();
 }
 
 function test_attach(response, tabClient) {
   tabClient.attachThread({}, function (response, threadClient) {
-    do_check_eq(threadClient.paused, true);
+    Assert.equal(threadClient.paused, true);
     threadClient.resume(function () {
       test_interrupt(threadClient);
     });
   });
 }
 
 function test_interrupt(threadClient) {
-  do_check_eq(threadClient.paused, false);
+  Assert.equal(threadClient.paused, false);
   threadClient.interrupt(function (response) {
-    do_check_eq(threadClient.paused, true);
+    Assert.equal(threadClient.paused, true);
     threadClient.resume(function () {
-      do_check_eq(threadClient.paused, false);
+      Assert.equal(threadClient.paused, false);
       cleanup();
     });
   });
 }
 
 function cleanup() {
   gClient.addListener("closed", function (event) {
     do_test_finished();
--- a/devtools/server/tests/unit/test_layout-reflows-observer.js
+++ b/devtools/server/tests/unit/test_layout-reflows-observer.js
@@ -91,202 +91,202 @@ function run_test() {
   observerIsAlreadyStarted();
   destroyStopsObserving();
   stoppingAndStartingSeveralTimesWorksCorrectly();
   reflowsArentStackedWhenStopped();
   stackedReflowsAreResetOnStop();
 }
 
 function instancesOfObserversAreSharedBetweenWindows() {
-  do_print("Checking that when requesting twice an instances of the observer " +
+  info("Checking that when requesting twice an instances of the observer " +
     "for the same TabActor, the instance is shared");
 
-  do_print("Checking 2 instances of the observer for the tabActor 1");
+  info("Checking 2 instances of the observer for the tabActor 1");
   let tabActor1 = new MockTabActor();
   let obs11 = getLayoutChangesObserver(tabActor1);
   let obs12 = getLayoutChangesObserver(tabActor1);
-  do_check_eq(obs11, obs12);
+  Assert.equal(obs11, obs12);
 
-  do_print("Checking 2 instances of the observer for the tabActor 2");
+  info("Checking 2 instances of the observer for the tabActor 2");
   let tabActor2 = new MockTabActor();
   let obs21 = getLayoutChangesObserver(tabActor2);
   let obs22 = getLayoutChangesObserver(tabActor2);
-  do_check_eq(obs21, obs22);
+  Assert.equal(obs21, obs22);
 
-  do_print("Checking that observers instances for 2 different tabActors are " +
+  info("Checking that observers instances for 2 different tabActors are " +
     "different");
-  do_check_neq(obs11, obs21);
+  Assert.notEqual(obs11, obs21);
 
   releaseLayoutChangesObserver(tabActor1);
   releaseLayoutChangesObserver(tabActor1);
   releaseLayoutChangesObserver(tabActor2);
   releaseLayoutChangesObserver(tabActor2);
 }
 
 function eventsAreBatched() {
-  do_print("Checking that reflow events are batched and only sent when the " +
+  info("Checking that reflow events are batched and only sent when the " +
     "timeout expires");
 
   // Note that in this test, we mock the TabActor and its window property, so we
   // also mock the setTimeout/clearTimeout mechanism and just call the callback
   // manually
   let tabActor = new MockTabActor();
   let observer = getLayoutChangesObserver(tabActor);
 
   let reflowsEvents = [];
   let onReflows = (event, reflows) => reflowsEvents.push(reflows);
   observer.on("reflows", onReflows);
 
   let resizeEvents = [];
   let onResize = () => resizeEvents.push("resize");
   observer.on("resize", onResize);
 
-  do_print("Fake one reflow event");
+  info("Fake one reflow event");
   tabActor.window.docShell.observer.reflow();
-  do_print("Checking that no batched reflow event has been emitted");
-  do_check_eq(reflowsEvents.length, 0);
+  info("Checking that no batched reflow event has been emitted");
+  Assert.equal(reflowsEvents.length, 0);
 
-  do_print("Fake another reflow event");
+  info("Fake another reflow event");
   tabActor.window.docShell.observer.reflow();
-  do_print("Checking that still no batched reflow event has been emitted");
-  do_check_eq(reflowsEvents.length, 0);
+  info("Checking that still no batched reflow event has been emitted");
+  Assert.equal(reflowsEvents.length, 0);
 
-  do_print("Fake a few of resize events too");
+  info("Fake a few of resize events too");
   tabActor.window.docShell.mockResize();
   tabActor.window.docShell.mockResize();
   tabActor.window.docShell.mockResize();
-  do_print("Checking that still no batched resize event has been emitted");
-  do_check_eq(resizeEvents.length, 0);
+  info("Checking that still no batched resize event has been emitted");
+  Assert.equal(resizeEvents.length, 0);
 
-  do_print("Faking timeout expiration and checking that events are sent");
+  info("Faking timeout expiration and checking that events are sent");
   observer.eventLoopTimer();
-  do_check_eq(reflowsEvents.length, 1);
-  do_check_eq(reflowsEvents[0].length, 2);
-  do_check_eq(resizeEvents.length, 1);
+  Assert.equal(reflowsEvents.length, 1);
+  Assert.equal(reflowsEvents[0].length, 2);
+  Assert.equal(resizeEvents.length, 1);
 
   observer.off("reflows", onReflows);
   observer.off("resize", onResize);
   releaseLayoutChangesObserver(tabActor);
 }
 
 function noEventsAreSentWhenThereAreNoReflowsAndLoopTimeouts() {
-  do_print("Checking that if no reflows were detected and the event batching " +
+  info("Checking that if no reflows were detected and the event batching " +
   "loop expires, then no reflows event is sent");
 
   let tabActor = new MockTabActor();
   let observer = getLayoutChangesObserver(tabActor);
 
   let reflowsEvents = [];
   let onReflows = (event, reflows) => reflowsEvents.push(reflows);
   observer.on("reflows", onReflows);
 
-  do_print("Faking timeout expiration and checking for reflows");
+  info("Faking timeout expiration and checking for reflows");
   observer.eventLoopTimer();
-  do_check_eq(reflowsEvents.length, 0);
+  Assert.equal(reflowsEvents.length, 0);
 
   observer.off("reflows", onReflows);
   releaseLayoutChangesObserver(tabActor);
 }
 
 function observerIsAlreadyStarted() {
-  do_print("Checking that the observer is already started when getting it");
+  info("Checking that the observer is already started when getting it");
 
   let tabActor = new MockTabActor();
   let observer = getLayoutChangesObserver(tabActor);
-  do_check_true(observer.isObserving);
+  Assert.ok(observer.isObserving);
 
   observer.stop();
-  do_check_false(observer.isObserving);
+  Assert.ok(!observer.isObserving);
 
   observer.start();
-  do_check_true(observer.isObserving);
+  Assert.ok(observer.isObserving);
 
   releaseLayoutChangesObserver(tabActor);
 }
 
 function destroyStopsObserving() {
-  do_print("Checking that the destroying the observer stops it");
+  info("Checking that the destroying the observer stops it");
 
   let tabActor = new MockTabActor();
   let observer = getLayoutChangesObserver(tabActor);
-  do_check_true(observer.isObserving);
+  Assert.ok(observer.isObserving);
 
   observer.destroy();
-  do_check_false(observer.isObserving);
+  Assert.ok(!observer.isObserving);
 
   releaseLayoutChangesObserver(tabActor);
 }
 
 function stoppingAndStartingSeveralTimesWorksCorrectly() {
-  do_print("Checking that the stopping and starting several times the observer" +
+  info("Checking that the stopping and starting several times the observer" +
     " works correctly");
 
   let tabActor = new MockTabActor();
   let observer = getLayoutChangesObserver(tabActor);
 
-  do_check_true(observer.isObserving);
+  Assert.ok(observer.isObserving);
   observer.start();
   observer.start();
   observer.start();
-  do_check_true(observer.isObserving);
+  Assert.ok(observer.isObserving);
 
   observer.stop();
-  do_check_false(observer.isObserving);
+  Assert.ok(!observer.isObserving);
 
   observer.stop();
   observer.stop();
-  do_check_false(observer.isObserving);
+  Assert.ok(!observer.isObserving);
 
   releaseLayoutChangesObserver(tabActor);
 }
 
 function reflowsArentStackedWhenStopped() {
-  do_print("Checking that when stopped, reflows aren't stacked in the observer");
+  info("Checking that when stopped, reflows aren't stacked in the observer");
 
   let tabActor = new MockTabActor();
   let observer = getLayoutChangesObserver(tabActor);
 
-  do_print("Stoping the observer");
+  info("Stoping the observer");
   observer.stop();
 
-  do_print("Faking reflows");
+  info("Faking reflows");
   tabActor.window.docShell.observer.reflow();
   tabActor.window.docShell.observer.reflow();
   tabActor.window.docShell.observer.reflow();
 
-  do_print("Checking that reflows aren't recorded");
-  do_check_eq(observer.reflows.length, 0);
+  info("Checking that reflows aren't recorded");
+  Assert.equal(observer.reflows.length, 0);
 
-  do_print("Starting the observer and faking more reflows");
+  info("Starting the observer and faking more reflows");
   observer.start();
   tabActor.window.docShell.observer.reflow();
   tabActor.window.docShell.observer.reflow();
   tabActor.window.docShell.observer.reflow();
 
-  do_print("Checking that reflows are recorded");
-  do_check_eq(observer.reflows.length, 3);
+  info("Checking that reflows are recorded");
+  Assert.equal(observer.reflows.length, 3);
 
   releaseLayoutChangesObserver(tabActor);
 }
 
 function stackedReflowsAreResetOnStop() {
-  do_print("Checking that stacked reflows are reset on stop");
+  info("Checking that stacked reflows are reset on stop");
 
   let tabActor = new MockTabActor();
   let observer = getLayoutChangesObserver(tabActor);
 
   tabActor.window.docShell.observer.reflow();
-  do_check_eq(observer.reflows.length, 1);
+  Assert.equal(observer.reflows.length, 1);
 
   observer.stop();
-  do_check_eq(observer.reflows.length, 0);
+  Assert.equal(observer.reflows.length, 0);
 
   tabActor.window.docShell.observer.reflow();
-  do_check_eq(observer.reflows.length, 0);
+  Assert.equal(observer.reflows.length, 0);
 
   observer.start();
-  do_check_eq(observer.reflows.length, 0);
+  Assert.equal(observer.reflows.length, 0);
 
   tabActor.window.docShell.observer.reflow();
-  do_check_eq(observer.reflows.length, 1);
+  Assert.equal(observer.reflows.length, 1);
 
   releaseLayoutChangesObserver(tabActor);
 }
--- a/devtools/server/tests/unit/test_listsources-01.js
+++ b/devtools/server/tests/unit/test_listsources-01.js
@@ -33,23 +33,23 @@ function run_test() {
                            });
   });
   do_test_pending();
 }
 
 function test_simple_listsources() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     gThreadClient.getSources(function (response) {
-      do_check_true(response.sources.some(function (s) {
+      Assert.ok(response.sources.some(function (s) {
         return s.url && s.url.match(/test_listsources-01.js/);
       }));
 
-      do_check_true(gNumTimesSourcesSent <= 1,
-                    "Should only send one sources request at most, even though we"
-                    + " might have had to send one to determine feature support.");
+      Assert.ok(gNumTimesSourcesSent <= 1,
+                "Should only send one sources request at most, even though we"
+                + " might have had to send one to determine feature support.");
 
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
   });
 
   /* eslint-disable */
--- a/devtools/server/tests/unit/test_listsources-02.js
+++ b/devtools/server/tests/unit/test_listsources-02.js
@@ -31,19 +31,19 @@ function run_test() {
                              test_listing_zero_sources();
                            });
   });
   do_test_pending();
 }
 
 function test_listing_zero_sources() {
   gThreadClient.getSources(function (packet) {
-    do_check_true(!packet.error);
-    do_check_true(!!packet.sources);
-    do_check_eq(packet.sources.length, 0);
+    Assert.ok(!packet.error);
+    Assert.ok(!!packet.sources);
+    Assert.equal(packet.sources.length, 0);
 
-    do_check_true(gNumTimesSourcesSent <= 1,
-                  "Should only send one sources request at most, even though we"
-                  + " might have had to send one to determine feature support.");
+    Assert.ok(gNumTimesSourcesSent <= 1,
+              "Should only send one sources request at most, even though we"
+              + " might have had to send one to determine feature support.");
 
     finishClient(gClient);
   });
 }
--- a/devtools/server/tests/unit/test_listsources-03.js
+++ b/devtools/server/tests/unit/test_listsources-03.js
@@ -23,21 +23,21 @@ function run_test() {
                            });
   });
   do_test_pending();
 }
 
 function test_simple_listsources() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     gThreadClient.getSources(function (response) {
-      do_check_true(
+      Assert.ok(
         !response.error,
         "There shouldn't be an error fetching large amounts of sources.");
 
-      do_check_true(response.sources.some(function (s) {
+      Assert.ok(response.sources.some(function (s) {
         return s.url.match(/foo-999.js$/);
       }));
 
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
   });
--- a/devtools/server/tests/unit/test_listsources-04.js
+++ b/devtools/server/tests/unit/test_listsources-04.js
@@ -27,22 +27,22 @@ function run_test_with_server(server, cb
     const client = new DebuggerClient(server.connectPipe());
     yield client.connect();
     const [,, threadClient] = yield attachTestTabAndResume(client, "test-sources");
 
     yield threadClient.reconfigure({ useSourceMaps: true });
     addSources(debuggee);
 
     threadClient.getSources(Task.async(function* (res) {
-      do_check_eq(res.sources.length, 3, "3 sources exist");
+      Assert.equal(res.sources.length, 3, "3 sources exist");
 
       yield threadClient.reconfigure({ useSourceMaps: false });
 
       threadClient.getSources(function (res) {
-        do_check_eq(res.sources.length, 1, "1 source exist");
+        Assert.equal(res.sources.length, 1, "1 source exist");
         client.close().then(cb);
       });
     }));
   });
 }
 
 function addSources(debuggee) {
   let { code, map } = (new SourceNode(null, null, null, [
--- a/devtools/server/tests/unit/test_longstringactor.js
+++ b/devtools/server/tests/unit/test_longstringactor.js
@@ -23,71 +23,71 @@ function makeMockLongStringActor() {