Issue 4796 - Use a modern JS engine in the browser tests and convert all files to ECMAScript 6

test/browser/_bootstrap.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2017 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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 "use strict";
 
 /* globals nodeunit */
 
 (function(nodeunitUrl, ...moduleUrls)

[Felix Dahlke, 2017/05/03 09:54:51]

As discussed on IRC, I find this approach of loading the code (i.e. as an
expression whose result is saved) a bit unintuitive. Maybe we could set
`module.exports` instead, CommonJS style?

[Wladimir Palant, 2017/05/03 12:19:42]

This isn't a module, we are loading code in global scope. So I'd rather not have
it touch any global symbols.

 {
   function loadScript(doc, url)
   {
     return new Promise((resolve, reject) =>
     {
       let script = doc.createElement("script");
       script.src = url;
       script.onload = resolve;
       doc.head.appendChild(script);
     });
   }
 
   function loadModules(urls)
   {
     let modules = {};
 
-    let loadNext = () =>

[Felix Dahlke, 2017/05/03 09:54:51]

I might be missing the reason for using let here, but if it's not actually
necessary, I would suggest to simplify the code like this:

  (function loadNext()
  {
    ...
  })();

[Wladimir Palant, 2017/05/03 12:19:42]

Not sure whether it makes the code better but ok.

+    return (function loadNext()
     {
       if (urls.length)
       {
         // Load each module into a new frame so that their scopes don't clash
         let frame = document.createElement("iframe");
         document.body.appendChild(frame);
 
         let wnd = frame.contentWindow;
         wnd.loadScript = url => loadScript(wnd.document, url);
         wnd.exports = {};
         wnd.module = {exports: wnd.exports};
 
         let url = urls.shift();
         let name = url.split("/").pop();
         return wnd.loadScript(url).then(() =>
         {
           modules[name] = nodeunit.testCase(wnd.module.exports);
           return loadNext();
         });
       }
 
       return Promise.resolve(modules);
-    };
-
-    return loadNext();
+    })();
   }
 
   function runTests(modules)
   {
     function bold(str)
     {
       return "\u001B[1m" + str + "\u001B[22m";
     }
 
     function ok(str)
     {
       return "\u001B[32m" + str + "\u001B[39m";
     }
 
     function error(str)
     {
       return "\u001B[31m" + str + "\u001B[39m";
     }
 
     return new Promise((resolve, reject) =>
     {
       nodeunit.runModules(modules, {
         moduleStart(name)
         {
           console.log(bold(name));
         },
         testDone(name, assertions)
         {
-          let errors = assertions.filter(assertion =>
-          {
-            return assertion.failed();
-          }).map(assertion =>
-          {
-            return assertion.error;
-          });

[Felix Dahlke, 2017/05/03 09:54:51]

Nit: How I see it, this could be shortened quite a bit without violating the 80
column rule:

  let errors = assertions.filter(assertion => assertion.failed())
    .map(assertion => assertion.error);

[Wladimir Palant, 2017/05/03 12:19:42]

Done.

+          let errors = assertions.filter(assertion => assertion.failed())
+                                 .map(assertion => assertion.error);
 
           if (errors.length == 0)
             console.log("\u2714 " + name);
           else
           {
             console.log(error("\u2716 " + name) + "\n");
             errors.forEach(e =>
             {
               if (e.stack)
                 console.log(e.stack);
               else
                 console.log(String(e));
               console.log("");
             });
           }
         },
         done(assertions)
         {
-          let failures = assertions.filter(assertion =>

[Felix Dahlke, 2017/05/03 09:54:51]

Nit: As above, I think this can be shortened:

  let failures = assertions.filter(assertion => assertion.failed());

[Wladimir Palant, 2017/05/03 12:19:42]

Done.

-          {
-            return assertion.failed();
-          });
+          let failures = assertions.filter(assertion => assertion.failed());
           if (failures.length)
           {
             console.log(
               "\n" +
               bold(error("FAILURES: ")) +
               failures.length + "/" + assertions.length + " assertions failed"
             );
           }
           else
           {
@@ skipping 10 matching lines @@
   }
 
   return loadScript(document, nodeunitUrl).then(() =>
   {
     return loadModules(moduleUrls);
   }).then(modules =>
   {
     return runTests(modules);
   });
 });