Issue 6959 - Use async/await in test/browser/elemHideEmulation.js

test/browser/elemHideEmulation.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 34 matching lines @@
 };
 
 function timeout(delay)
 {
   return new Promise((resolve, reject) =>
   {
     window.setTimeout(resolve, delay);
   });
 }
 
-function unexpectedError(error)
+function unexpectedError(test, error)
 {
   console.error(error);
-  this.ok(false, "Unexpected error: " + error);
+  test.ok(false, "Unexpected error: " + error);
 }
 
 function expectHidden(test, element, id)
 {
   let withId = "";
   if (typeof id != "undefined")
     withId = ` with ID '${id}'`;
 
   test.equal(
     window.getComputedStyle(element).display, "none",
@@ skipping 76 matching lines @@
   let element = createElement(parent);
   insertStyleRule("#" + element.id + " " + styleBlock);
   return element;
 }
 
 // Create a new ElemHideEmulation instance with @selectors.
 async function applyElemHideEmulation(test, selectors)
 {
   await Promise.resolve();
 
-  let elemHideEmulation = null;
-
   try
   {
-    elemHideEmulation = new ElemHideEmulation(
+    let elemHideEmulation = new ElemHideEmulation(
       elems =>
       {
         for (let elem of elems)
           elem.style.display = "none";
       }
     );
 
     elemHideEmulation.document = testDocument;
     elemHideEmulation.MIN_INVOCATION_INTERVAL = REFRESH_INTERVAL / 2;
     elemHideEmulation.apply(selectors.map(
       selector => ({selector, text: selector})
     ));
 
     return elemHideEmulation;
   }
   catch (error)
   {
-    unexpectedError.call(test, error);
+    unexpectedError(test, error);
   }
 }
 
 exports.testVerbatimPropertySelector = async function(test)
 {
   let toHide = createElementWithStyle("{background-color: #000}");
-
-  if (await applyElemHideEmulation(
-    test,
-    [":-abp-properties(background-color: rgb(0, 0, 0))"]
-  ))
-  {
+  let selectors = [":-abp-properties(background-color: rgb(0, 0, 0))"];
+
+  if (await applyElemHideEmulation(test, selectors))
     expectHidden(test, toHide);
-  }
 
   test.done();
 };
 
 exports.testVerbatimPropertySelectorWithPrefix = async function(test)
 {
   let parent = createElementWithStyle("{background-color: #000}");
   let toHide = createElementWithStyle("{background-color: #000}", parent);
 
-  if (await applyElemHideEmulation(
-    test,
-    ["div > :-abp-properties(background-color: rgb(0, 0, 0))"]
-  ))
+  let selectors = ["div > :-abp-properties(background-color: rgb(0, 0, 0))"];
+
+  if (await applyElemHideEmulation(test, selectors))
   {
     expectVisible(test, parent);
     expectHidden(test, toHide);
   }
 
   test.done();
 };
 
 exports.testVerbatimPropertySelectorWithPrefixNoMatch = async function(test)
 {
   let parent = createElementWithStyle("{background-color: #000}");
   let toHide = createElementWithStyle("{background-color: #fff}", parent);
 
-  if (await applyElemHideEmulation(
-    test,
-    ["div > :-abp-properties(background-color: rgb(0, 0, 0))"]
-  ))
+  let selectors = ["div > :-abp-properties(background-color: rgb(0, 0, 0))"];
+
+  if (await applyElemHideEmulation(test, selectors))
   {
     expectVisible(test, parent);
     expectVisible(test, toHide);
   }
 
   test.done();
 };
 
 exports.testVerbatimPropertySelectorWithSuffix = async function(test)
 {
   let parent = createElementWithStyle("{background-color: #000}");
   let toHide = createElementWithStyle("{background-color: #000}", parent);
 
-  if (await applyElemHideEmulation(
-    test,
-    [":-abp-properties(background-color: rgb(0, 0, 0)) > div"]
-  ))
+  let selectors = [":-abp-properties(background-color: rgb(0, 0, 0)) > div"];
+
+  if (await applyElemHideEmulation(test, selectors))
   {
     expectVisible(test, parent);
     expectHidden(test, toHide);
   }
 
   test.done();
 };
 
 exports.testVerbatimPropertyPseudoSelectorWithPrefixAndSuffix = async function(test)
 {
   let parent = createElementWithStyle("{background-color: #000}");
   let middle = createElementWithStyle("{background-color: #000}", parent);
   let toHide = createElementWithStyle("{background-color: #000}", middle);
 
-  if (await applyElemHideEmulation(
-    test,
-    ["div > :-abp-properties(background-color: rgb(0, 0, 0)) > div"]
-  ))
+  let selectors = ["div > :-abp-properties(background-color: rgb(0, 0, 0)) > div"];
+
+  if (await applyElemHideEmulation(test, selectors))
   {
     expectVisible(test, parent);
     expectVisible(test, middle);
     expectHidden(test, toHide);
   }
 
   test.done();
 };
 
 // Add the style. Then add the element for that style.
 // This should retrigger the filtering and hide it.
 exports.testPropertyPseudoSelectorAddStyleAndElement = async function(test)
 {
   let styleElement;
   let toHide;
 
-  if (await applyElemHideEmulation(
-    test,
-    [":-abp-properties(background-color: rgb(0, 0, 0))"]
-  ))
+  let selectors = [":-abp-properties(background-color: rgb(0, 0, 0))"];
+
+  if (await applyElemHideEmulation(test, selectors))
   {
     styleElement = testDocument.createElement("style");
     testDocument.head.appendChild(styleElement);
     styleElement.sheet.insertRule("#toHide {background-color: #000}");
     await timeout(REFRESH_INTERVAL);
 
     toHide = createElement();
     toHide.id = "toHide";
     expectVisible(test, toHide);
     await timeout(REFRESH_INTERVAL);
 
     expectHidden(test, toHide);
   }
 
   test.done();
 };
 
 exports.testPropertySelectorWithWildcard = async function(test)
 {
   let toHide = createElementWithStyle("{background-color: #000}");
-
-  if (await applyElemHideEmulation(
-    test,
-    [":-abp-properties(*color: rgb(0, 0, 0))"]
-  ))
-  {
+  let selectors = [":-abp-properties(*color: rgb(0, 0, 0))"];
+
+  if (await applyElemHideEmulation(test, selectors))
     expectHidden(test, toHide);
-  }
 
   test.done();
 };
 
 exports.testPropertySelectorWithRegularExpression = async function(test)
 {
   let toHide = createElementWithStyle("{background-color: #000}");
-
-  if (await applyElemHideEmulation(
-    test,
-    [":-abp-properties(/.*color: rgb\\(0, 0, 0\\)/)"]
-  ))
-  {
+  let selectors = [":-abp-properties(/.*color: rgb\\(0, 0, 0\\)/)"];
+
+  if (await applyElemHideEmulation(test, selectors))
     expectHidden(test, toHide);
-  }
 
   test.done();
 };
 
 exports.testPropertySelectorWithEscapedBrace = async function(test)
 {
   let toHide = createElementWithStyle("{background-color: #000}");
-
-  if (await applyElemHideEmulation(
-    test,
-    [":-abp-properties(/background.\\7B 0,6\\7D : rgb\\(0, 0, 0\\)/)"]
-  ))
-  {
+  let selectors = [":-abp-properties(/background.\\7B 0,6\\7D : rgb\\(0, 0, 0\\)/)"];
+
+  if (await applyElemHideEmulation(test, selectors))
     expectHidden(test, toHide);
-  }
 
   test.done();
 };
 
 exports.testPropertySelectorWithImproperlyEscapedBrace = async function(test)
 {
   let toHide = createElementWithStyle("{background-color: #000}");
-
-  if (await applyElemHideEmulation(
-    test,
-    [":-abp-properties(/background.\\7B0,6\\7D: rgb\\(0, 0, 0\\)/)"]
-  ))
-  {
+  let selectors = [":-abp-properties(/background.\\7B0,6\\7D: rgb\\(0, 0, 0\\)/)"];
+
+  if (await applyElemHideEmulation(test, selectors))
     expectVisible(test, toHide);
-  }
 
   test.done();
 };
 
 exports.testDynamicallyChangedProperty = async function(test)
 {
   let toHide = createElementWithStyle("{}");
-
-  if (await applyElemHideEmulation(
-    test,
-    [":-abp-properties(background-color: rgb(0, 0, 0))"]
-  ))
+  let selectors = [":-abp-properties(background-color: rgb(0, 0, 0))"];
+
+  if (await applyElemHideEmulation(test, selectors))
   {
     expectVisible(test, toHide);
     insertStyleRule("#" + toHide.id + " {background-color: #000}");
 
     await timeout(0);
 
     // Re-evaluation will only happen after a delay
     expectVisible(test, toHide);
     await timeout(REFRESH_INTERVAL);
 
     expectHidden(test, toHide);
   }
 
   test.done();
 };
 
 exports.testPseudoClassWithPropBeforeSelector = async function(test)
 {
   let parent = createElementWithStyle("{}");
   let child = createElementWithStyle("{background-color: #000}", parent);
+
+  let selectors = ["div:-abp-properties(content: \"publicite\")"];
+
   insertStyleRule(`#${child.id}::before {content: "publicite"}`);
 
-  if (await applyElemHideEmulation(
-    test,
-    ["div:-abp-properties(content: \"publicite\")"]
-  ))
+  if (await applyElemHideEmulation(test, selectors))
   {
     expectHidden(test, child);
     expectVisible(test, parent);
   }
 
   test.done();
 };
 
 exports.testPseudoClassHasSelector = async function(test)
 {
@@ skipping 112 matching lines @@
   };
 
   insertStyleRule(".inside {}");
 
   if (await applyElemHideEmulation(test, [selector]))
     compareExpectations(test, elems, expectations);
 
   test.done();
 }
 
-exports.testPseudoClassHasSelectorWithHasAndWithSuffixSibling = async function(test)
+exports.testPseudoClassHasSelectorWithHasAndWithSuffixSibling = function(test)
 {
   let expectations = {
     parent: true,
     middile: true,
     inside: true,
     sibling: true,
     sibling2: true,
     toHide: false
   };
   runTestPseudoClassHasSelectorWithHasAndWithSuffixSibling(
     test, "div:-abp-has(:-abp-has(div.inside)) + div > div", expectations);
 };
 
-exports.testPseudoClassHasSelectorWithHasAndWithSuffixSibling2 = async function(test)
+exports.testPseudoClassHasSelectorWithHasAndWithSuffixSibling2 = function(test)
 {
   let expectations = {
     parent: true,
     middile: true,
     inside: true,
     sibling: true,
     sibling2: true,
     toHide: false
   };
   runTestPseudoClassHasSelectorWithHasAndWithSuffixSibling(
     test, "div:-abp-has(:-abp-has(> div.inside)) + div > div", expectations);
 };
 
-exports.testPseudoClassHasSelectorWithHasAndWithSuffixSibling3 = async function(test)
+exports.testPseudoClassHasSelectorWithHasAndWithSuffixSibling3 = function(test)
 {
   let expectations = {
     parent: true,
     middile: true,
     inside: true,
     sibling: true,
     sibling2: true,
     toHide: false
   };
   runTestPseudoClassHasSelectorWithHasAndWithSuffixSibling(
     test, "div:-abp-has(> div:-abp-has(div.inside)) + div > div", expectations);
 };
 
-exports.testPseudoClassHasSelectorWithSuffixSiblingNoop = async function(test)
+exports.testPseudoClassHasSelectorWithSuffixSiblingNoop = function(test)
 {
   let expectations = {
     parent: true,
     middile: true,
     inside: true,
     sibling: true,
     sibling2: true,
     toHide: true
   };
   runTestPseudoClassHasSelectorWithHasAndWithSuffixSibling(
     test, "div:-abp-has(> body div.inside) + div > div", expectations);
 };
 
-exports.testPseudoClassHasSelectorWithSuffixSiblingContains = async function(test)
+exports.testPseudoClassHasSelectorWithSuffixSiblingContains = function(test)
 {
   let expectations = {
     parent: true,
     middile: true,
     inside: true,
     sibling: true,
     sibling2: true,
     toHide: true
   };
   runTestPseudoClassHasSelectorWithHasAndWithSuffixSibling(
@@ skipping 21 matching lines @@
     sibling2: testDocument.getElementById("sibling2"),
     toHide: testDocument.getElementById("tohide")
   };
 
   if (await applyElemHideEmulation(test, [selector]))
     compareExpectations(test, elems, expectations);
 
   test.done();
 }
 
-exports.testPseudoClassContainsText = async function(test)
+exports.testPseudoClassContainsText = function(test)
 {
   let expectations = {
     parent: true,
     middle: true,
     inside: true,
     sibling: false,
     sibling2: true,
     toHide: true
   };
   runTestPseudoClassContains(
     test, "#parent div:-abp-contains(to hide)", expectations);
 };
 
-exports.testPseudoClassContainsRegexp = async function(test)
+exports.testPseudoClassContainsRegexp = function(test)
 {
   let expectations = {
     parent: true,
     middle: true,
     inside: true,
     sibling: false,
     sibling2: true,
     toHide: true
   };
   runTestPseudoClassContains(
     test, "#parent div:-abp-contains(/to\\shide/)", expectations);
 };
 
-exports.testPseudoClassContainsRegexpIFlag = async function(test)
+exports.testPseudoClassContainsRegexpIFlag = function(test)
 {
   let expectations = {
     parent: true,
     middle: true,
     inside: true,
     sibling: false,
     sibling2: true,
     toHide: true
   };
   runTestPseudoClassContains(
     test, "#parent div:-abp-contains(/to\\sHide/i)", expectations);
 };
 
-exports.testPseudoClassContainsRegexpUFlag = async function(test)
+exports.testPseudoClassContainsRegexpUFlag = function(test)
 {
   let expectations = {
     parent: true,
     middle: true,
     inside: true,
     sibling: false,
     sibling2: true,
     toHide: true
   };
   runTestPseudoClassContains(
     test, "#parent div:-abp-contains(/to\\shide\\s.!/u)", expectations);
 };
 
-exports.testPseudoClassContainsWildcardNoMatch = async function(test)
+exports.testPseudoClassContainsWildcardNoMatch = function(test)
 {
   let expectations = {
     parent: true,
     middle: true,
     inside: true,
     sibling: true,
     sibling2: true,
     toHide: true
   };
   // this filter shouldn't match anything as "*" has no meaning.
   runTestPseudoClassContains(
     test, "#parent div:-abp-contains(to *hide)", expectations);
 };
 
-exports.testPseudoClassContainsWildcardMatch = async function(test)
+exports.testPseudoClassContainsWildcardMatch = function(test)
 {
   let expectations = {
     parent: true,
     middle: true,
     inside: true,
     sibling: true,
     sibling2: false,
     toHide: true
   };
   runTestPseudoClassContains(
     test, "#parent div:-abp-contains(Ad*)", expectations);
 };
 
 exports.testPseudoClassHasSelectorWithPropSelector = async function(test)
 {
   let parent = createElementWithStyle("{}");
   let child = createElementWithStyle("{background-color: #000}", parent);
 
-  if (await applyElemHideEmulation(
-    test,
-    ["div:-abp-has(:-abp-properties(background-color: rgb(0, 0, 0)))"]
-  ))
+  let selectors = ["div:-abp-has(:-abp-properties(background-color: rgb(0, 0, 0)))"];
+
+  if (await applyElemHideEmulation(test, selectors))
   {
     expectVisible(test, child);
     expectHidden(test, parent);
   }
 
   test.done();
 };
 
 exports.testPseudoClassHasSelectorWithPropSelector2 = async function(test)
 {
   let parent = createElementWithStyle("{}");
   let child = createElementWithStyle("{}", parent);
+
+  let selectors = ["div:-abp-has(:-abp-properties(background-color: rgb(0, 0, 0)))"];
+
   insertStyleRule("body #" + parent.id + " > div { background-color: #000}");
 
-  if (await applyElemHideEmulation(
-    test,
-    ["div:-abp-has(:-abp-properties(background-color: rgb(0, 0, 0)))"]
-  ))
+  if (await applyElemHideEmulation(test, selectors))
   {
     expectVisible(test, child);
     expectHidden(test, parent);
   }
 
   test.done();
 };
 
 exports.testDomUpdatesStyle = async function(test)
 {
   let parent = createElementWithStyle("{}");
   let child = createElementWithStyle("{}", parent);
 
-  if (await applyElemHideEmulation(
-    test,
-    ["div:-abp-has(:-abp-properties(background-color: rgb(0, 0, 0)))"]
-  ))
+  let selectors = ["div:-abp-has(:-abp-properties(background-color: rgb(0, 0, 0)))"];
+
+  if (await applyElemHideEmulation(test, selectors))
   {
     expectVisible(test, child);
     expectVisible(test, parent);
 
     insertStyleRule("body #" + parent.id + " > div { background-color: #000}");
     await timeout(0);
 
     expectVisible(test, child);
     expectVisible(test, parent);
     await timeout(REFRESH_INTERVAL);
 
     expectVisible(test, child);
     expectHidden(test, parent);
   }
 
   test.done();
 };
 
 exports.testDomUpdatesContent = async function(test)
 {
   let parent = createElementWithStyle("{}");
   let child = createElementWithStyle("{}", parent);
 
-  if (await applyElemHideEmulation(
-    test,
-    ["div > div:-abp-contains(hide me)"]
-  ))
+  if (await applyElemHideEmulation(test, ["div > div:-abp-contains(hide me)"]))
   {
     expectVisible(test, parent);
     expectVisible(test, child);
 
     child.textContent = "hide me";
     await timeout(0);
 
     expectVisible(test, parent);
     expectVisible(test, child);
     await timeout(REFRESH_INTERVAL);
 
     expectVisible(test, parent);
     expectHidden(test, child);
   }
 
   test.done();
 };
 
 exports.testDomUpdatesNewElement = async function(test)
 {
   let parent = createElementWithStyle("{}");
   let child = createElementWithStyle("{ background-color: #000}", parent);
   let sibling;
   let child2;
 
-  if (await applyElemHideEmulation(
-    test,
-    ["div:-abp-has(:-abp-properties(background-color: rgb(0, 0, 0)))"]
-  ))
+  let selectors = ["div:-abp-has(:-abp-properties(background-color: rgb(0, 0, 0)))"];
+
+  if (await applyElemHideEmulation(test, selectors))
   {
     expectHidden(test, parent);
     expectVisible(test, child);
 
     sibling = createElementWithStyle("{}");
     await timeout(0);
 
     expectHidden(test, parent);
     expectVisible(test, child);
     expectVisible(test, sibling);
@@ skipping 18 matching lines @@
   }
 
   test.done();
 };
 
 exports.testPseudoClassPropertiesOnStyleSheetLoad = async function(test)
 {
   let parent = createElement();
   let child = createElement(parent);
 
-  if (await applyElemHideEmulation(
-    test,
-    ["div:-abp-properties(background-color: rgb(0, 0, 0))",
-     "div:-abp-contains(hide me)",
-     "div:-abp-has(> div.hideMe)"]
-  ))
+  let selectors = [
+    "div:-abp-properties(background-color: rgb(0, 0, 0))",
+    "div:-abp-contains(hide me)",
+    "div:-abp-has(> div.hideMe)"
+  ];
+
+  if (await applyElemHideEmulation(test, selectors))
   {
     await timeout(REFRESH_INTERVAL);
 
     expectVisible(test, parent);
     expectVisible(test, child);
 
     // Load a style sheet that targets the parent element. This should run only
     // the "div:-abp-properties(background-color: rgb(0, 0, 0))" pattern.
     insertStyleRule("#" + parent.id + " {background-color: #000}");
 
     await timeout(REFRESH_INTERVAL);
 
     expectHidden(test, parent);
     expectVisible(test, child);
   }
 
   test.done();
 };
 
 exports.testPlainAttributeOnDomMutation = async function(test)
 {
   let parent = createElement();
   let child = createElement(parent);
 
-  if (await applyElemHideEmulation(
-    test,
-    ["div:-abp-properties(background-color: rgb(0, 0, 0))",
-     "div[data-hide-me]",
-     "div:-abp-contains(hide me)",
-     "div:-abp-has(> div.hideMe)"]
-  ))
+  let selectors = [
+    "div:-abp-properties(background-color: rgb(0, 0, 0))",
+    "div[data-hide-me]",
+    "div:-abp-contains(hide me)",
+    "div:-abp-has(> div.hideMe)"
+  ];
+
+  if (await applyElemHideEmulation(test, selectors))
   {
     await timeout(REFRESH_INTERVAL);
 
     expectVisible(test, parent);
     expectVisible(test, child);
 
     // Set the "data-hide-me" attribute on the child element.
     //
     // Note: Since the "div[data-hide-me]" pattern has already been processed
     // and the selector added to the document's style sheet, this will in fact
     // not do anything at our end, but the browser will just match the selector
     // and hide the element.
     child.setAttribute("data-hide-me", "");
 
     await timeout(REFRESH_INTERVAL);
 
     expectVisible(test, parent);
     expectHidden(test, child);
   }
 
   test.done();
 };
 
 exports.testPseudoClassContainsOnDomMutation = async function(test)
 {
   let parent = createElement();
   let child = createElement(parent);
 
+  let selectors = [
+    "div:-abp-properties(background-color: rgb(0, 0, 0))",
+    "div[data-hide-me]",
+    "div:-abp-contains(hide me)",
+    "div:-abp-has(> div.hideMe)"
+  ];
+
   child.innerText = "do nothing";
 
-  if (await applyElemHideEmulation(
-    test,
-    ["div:-abp-properties(background-color: rgb(0, 0, 0))",
-     "div[data-hide-me]",
-     "div:-abp-contains(hide me)",
-     "div:-abp-has(> div.hideMe)"]
-  ))
+  if (await applyElemHideEmulation(test, selectors))
   {
     await timeout(REFRESH_INTERVAL);
 
     expectVisible(test, parent);
     expectVisible(test, child);
 
     // Set the child element's text to "hide me". This should run only the
     // "div:-abp-contains(hide me)" pattern.
     //
     // Note: We need to set Node.innerText here in order to trigger the
     // "characterData" DOM mutation on Chromium. If we set Node.textContent
     // instead, it triggers the "childList" DOM mutation instead.
     child.innerText = "hide me";
 
     await timeout(REFRESH_INTERVAL);
 
     expectHidden(test, parent);
     expectVisible(test, child);
   }
 
   test.done();
 };
 
 exports.testPseudoClassHasOnDomMutation = async function(test)
 {
   let parent = createElement();
   let child = null;
 
-  if (await applyElemHideEmulation(
-    test,
-    ["div:-abp-properties(background-color: rgb(0, 0, 0))",
-     "div[data-hide-me]",
-     "div:-abp-contains(hide me)",
-     "div:-abp-has(> div)"]
-  ))
+  let selectors = [
+    "div:-abp-properties(background-color: rgb(0, 0, 0))",
+    "div[data-hide-me]",
+    "div:-abp-contains(hide me)",
+    "div:-abp-has(> div)"
+  ];
+
+  if (await applyElemHideEmulation(test, selectors))
   {
     await timeout(REFRESH_INTERVAL);
 
     expectVisible(test, parent);
 
     // Add the child element. This should run all the DOM-dependent patterns
     // ("div:-abp-contains(hide me)" and "div:-abp-has(> div)").
     child = createElement(parent);
 
     await timeout(REFRESH_INTERVAL);
 
     expectHidden(test, parent);
     expectVisible(test, child);
   }
 
   test.done();
 };
 
 exports.testPseudoClassHasWithClassOnDomMutation = async function(test)
 {
   let parent = createElement();
   let child = createElement(parent);
 
-  if (await applyElemHideEmulation(
-    test,
-    ["div:-abp-properties(background-color: rgb(0, 0, 0))",
-     "div[data-hide-me]",
-     "div:-abp-contains(hide me)",
-     "div:-abp-has(> div.hideMe)"]
-  ))
+  let selectors = [
+    "div:-abp-properties(background-color: rgb(0, 0, 0))",
+    "div[data-hide-me]",
+    "div:-abp-contains(hide me)",
+    "div:-abp-has(> div.hideMe)"
+  ];
+
+  if (await applyElemHideEmulation(test, selectors))
   {
     await timeout(REFRESH_INTERVAL);
 
     expectVisible(test, parent);
     expectVisible(test, child);
 
     // Set the child element's class to "hideMe". This should run only the
     // "div:-abp-has(> div.hideMe)" pattern.
     child.className = "hideMe";
 
     await timeout(REFRESH_INTERVAL);
 
     expectHidden(test, parent);
     expectVisible(test, child);
   }
 
   test.done();
 };
 
 exports.testPseudoClassHasWithPseudoClassContainsOnDomMutation = async function(test)
 {
   let parent = createElement();
   let child = createElement(parent);
 
+  let selectors = [
+    "div:-abp-properties(background-color: rgb(0, 0, 0))",
+    "div[data-hide-me]",
+    "div:-abp-contains(hide me)",
+    "div:-abp-has(> div:-abp-contains(hide me))"
+  ];
+
   child.innerText = "do nothing";
 
-  if (await applyElemHideEmulation(
-    test,
-    ["div:-abp-properties(background-color: rgb(0, 0, 0))",
-     "div[data-hide-me]",
-     "div:-abp-contains(hide me)",
-     "div:-abp-has(> div:-abp-contains(hide me))"]
-  ))
+  if (await applyElemHideEmulation(test, selectors))
   {
     await timeout(REFRESH_INTERVAL);
 
     expectVisible(test, parent);
     expectVisible(test, child);
 
     // Set the child element's text to "hide me". This should run only the
     // "div:-abp-contains(hide me)" and
     // "div:-abp-has(> div:-abp-contains(hide me))" patterns.
     child.innerText = "hide me";
@@ skipping 33 matching lines @@
   //     <p id="n4_4">Hello</p>
   //   </div>
   // </body>
   for (let i of [1, 2, 3, 4])
   {
     let n = createElement(null, "div", `n${i}`);
     for (let [j, text] of [[1], [2], [4, "Hello"]])
       createElement(n, "p", `n${i}_${j}`, text);
   }
 
-  if (await applyElemHideEmulation(
-    test,
-    ["p:-abp-contains(Hello)",
-     "div:-abp-contains(Try me!)",
-     "div:-abp-has(p:-abp-contains(This is good))"]
-  ))
+  let selectors = [
+    "p:-abp-contains(Hello)",
+    "div:-abp-contains(Try me!)",
+    "div:-abp-has(p:-abp-contains(This is good))"
+  ];
+
+  if (await applyElemHideEmulation(test, selectors))
   {
     await timeout(REFRESH_INTERVAL);
 
     // This is only a sanity check to make sure everything else is working
     // before we do the actual test.
     for (let i of [1, 2, 3, 4])
     {
       for (let j of [1, 2, 4])
       {
         let id = `n${i}_${j}`;
@@ skipping 40 matching lines @@
     {
       if (element.id == "n2" || element.id == "n2_3")
         expectProcessed(test, element, element.id);
       else
         expectNotProcessed(test, element, element.id);
     }
   }
 
   test.done();
 };