The Tor Browser: testing/mochitest/chrome-harness.js@7e26c7da4463 (annotated)

testing/mochitest/chrome-harness.js@7e26c7da4463 (annotated)

testing/mochitest/chrome-harness.js

Wed, 31 Dec 2014 06:55:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:55:50 +0100
changeset 2: 7e26c7da4463
permissions: -rw-r--r--

Added tag UPSTREAM_283F7C6 for changeset ca08bd8f51b2

 /* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:set ts=2 sw=2 sts=2 et: */
 /* 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/. */
 Components.utils.import("resource://gre/modules/NetUtil.jsm");
 /*
  * getChromeURI converts a URL to a URI
  *
  * url: string of a URL (http://mochi.test/test.html)
  * returns: a nsiURI object representing the given URL
  *
  */
 function getChromeURI(url) {
   var ios = Components.classes["@mozilla.org/network/io-service;1"].
               getService(Components.interfaces.nsIIOService);
   return ios.newURI(url, null, null);
 }
 /*
  * Convert a URL (string) into a nsIURI or NSIJARURI
  * This is intended for URL's that are on a file system
  * or in packaged up in an extension .jar file
  *
  * url: a string of a url on the local system(http://localhost/blah.html)
  */
 function getResolvedURI(url) {
   var chromeURI = getChromeURI(url);
   var resolvedURI = Components.classes["@mozilla.org/chrome/chrome-registry;1"].
                     getService(Components.interfaces.nsIChromeRegistry).
                     convertChromeURL(chromeURI);
   try {
     resolvedURI = resolvedURI.QueryInterface(Components.interfaces.nsIJARURI);
   } catch (ex) {} //not a jar file
   return resolvedURI;
 }
 /**
  *  getChromeDir is intended to be called after getResolvedURI and convert
  *  the input URI into a nsILocalFile (actually the directory containing the
  *  file).  This can be used for copying or referencing the file or extra files
  *  required by the test.  Usually we need to load a secondary html file or library
  *  and this will give us file system access to that.
  *
  *  resolvedURI: nsIURI (from getResolvedURI) that points to a file:/// url
  */
 function getChromeDir(resolvedURI) {
   var fileHandler = Components.classes["@mozilla.org/network/protocol;1?name=file"].
                     getService(Components.interfaces.nsIFileProtocolHandler);
   var chromeDir = fileHandler.getFileFromURLSpec(resolvedURI.spec);
   return chromeDir.parent.QueryInterface(Components.interfaces.nsILocalFile);
 }
 /*
  * given a .jar file, we get all test files located inside the archive
  *
  * aBasePath: base URL to determine chrome location and search for tests
  * aTestPath: passed in testPath value from command line such as: dom/tests/mochitest
  * aDir: the test dir to append to the baseURL after getting a directory interface
  *
  * As a note, this is hardcoded to the .jar structure we use for mochitest.
  * Please don't assume this works for all jar files.
  */
 function getMochitestJarListing(aBasePath, aTestPath, aDir)
 {
   var zReader = Components.classes["@mozilla.org/libjar/zip-reader;1"].
                   createInstance(Components.interfaces.nsIZipReader);
   var fileHandler = Components.classes["@mozilla.org/network/protocol;1?name=file"].
                     getService(Components.interfaces.nsIFileProtocolHandler);
   var fileName = fileHandler.getFileFromURLSpec(getResolvedURI(aBasePath).JARFile.spec);
   zReader.open(fileName);
   //hardcoded 'content' as that is the root dir in the mochikit.jar file
   var idx = aBasePath.indexOf('/content');
   var basePath = aBasePath.slice(0, idx);
   var base = "content/" + aDir + "/";
   if (aTestPath) {
     var extraPath = aTestPath;
     var pathToCheck = base + aTestPath;
     if (zReader.hasEntry(pathToCheck)) {
       var pathEntry = zReader.getEntry(pathToCheck);
       if (pathEntry.isDirectory) {
         base = pathToCheck;
       } else {
         var singleTestPath = basePath + '/' + base + aTestPath;
         var singleObject = {};
         singleObject[singleTestPath] = true;
         return singleObject;
       }
     }
     else if (zReader.hasEntry(pathToCheck + "/")) {
       base = pathToCheck + "/";
     }
     else {
       return null;
     }
   }
   var [links, count] = zList(base, zReader, basePath, true);
   return links;
 }
 /*
  * Replicate the server.js list() function with a .jar file
  *
  * base: string value of base directory we are testing
  * zReader: handle to opened nsIZipReader object
  * recurse: true|false if we do subdirs
  *
  * returns:
  *  [json object of {dir:{subdir:{file:true, file:true, ...}}}, count of tests]
  */
 function zList(base, zReader, baseJarName, recurse) {
   var dirs = zReader.findEntries(base + "*");
   var links = {};
   var count = 0;
   var fileArray = [];
   while(dirs.hasMore()) {
     var entryName = dirs.getNext();
     if (entryName.substr(-1) == '/' && entryName.split('/').length == (base.split('/').length + 1) ||
         (entryName.substr(-1) != '/' && entryName.split('/').length == (base.split('/').length))) {
       fileArray.push(entryName);
     }
   }
   fileArray.sort();
   count = fileArray.length;
   for (var i=0; i < fileArray.length; i++) {
     var myFile = fileArray[i];
     if (myFile.substr(-1) === '/' && recurse) {
       var childCount = 0;
       [links[myFile], childCount] = zList(myFile, zReader, baseJarName, recurse);
       count += childCount;
     } else {
       if (myFile.indexOf("SimpleTest") == -1) {
         //we add the '/' so we don't try to run content/content/chrome
         links[baseJarName + '/' + myFile] = true;
       }
     }
   }
   return [links, count];
 }
 /**
  * basePath: the URL base path to search from such as chrome://mochikit/content/a11y
  * testPath: the optional testPath passed into the test such as dom/tests/mochitest
  * dir: the test dir to append to the uri after getting a directory interface
  * srvScope: loaded javascript to server.js so we have aComponents.classesess to the list() function
  *
  * return value:
  *  single test: [json object, path to test]
  *  list of tests: [json object, null] <- directory [heirarchy]
  */
 function getFileListing(basePath, testPath, dir, srvScope)
 {
   var uri = getResolvedURI(basePath);
   var chromeDir = getChromeDir(uri);
   chromeDir.appendRelativePath(dir);
   basePath += '/' + dir;
   if (testPath == "false" || testPath == false) {
     testPath = "";
   }
   var ioSvc = Components.classes["@mozilla.org/network/io-service;1"].
               getService(Components.interfaces.nsIIOService);
   var testsDirURI = ioSvc.newFileURI(chromeDir);
   var testsDir = ioSvc.newURI(testPath, null, testsDirURI)
                   .QueryInterface(Components.interfaces.nsIFileURL).file;
   if (testPath != undefined) {
     var extraPath = testPath;
     var fileNameRegexp = /(browser|test)_.+\.(xul|html|js)$/;
     // Invalid testPath...
     if (!testsDir.exists())
       return null;
     if (testsDir.isFile()) {
       if (fileNameRegexp.test(testsDir.leafName)) {
         var singlePath = basePath + '/' + testPath;
         var links = {};
         links[singlePath] = true;
         return links;
       }
       // We were passed a file that's not a test...
       return null;
     }
     // otherwise, we were passed a directory of tests
     basePath += "/" + testPath;
   }
   var [links, count] = srvScope.list(basePath, testsDir, true);
   return links;
 }
 //used by tests to determine their directory based off window.location.path
 function getRootDirectory(path, chromeURI) {
   if (chromeURI === undefined)
   {
     chromeURI = getChromeURI(path);
   }
   var myURL = chromeURI.QueryInterface(Components.interfaces.nsIURL);
   var mydir = myURL.directory;
   if (mydir.match('/$') != '/')
   {
     mydir += '/';
   }
   return chromeURI.prePath + mydir;
 }
 //used by tests to determine their directory based off window.location.path
 function getChromePrePath(path, chromeURI) {
   if (chromeURI === undefined) {
     chromeURI = getChromeURI(path);
   }
   return chromeURI.prePath;
 }
 /*
  * Given a URI, return nsIJARURI or null
  */
 function getJar(uri) {
   var resolvedURI = getResolvedURI(uri);
   var jar = null;
   try {
     if (resolvedURI.JARFile) {
       jar = resolvedURI;
     }
   } catch (ex) {}
   return jar;
 }
 /*
  * input:
  *  jar: a nsIJARURI object with the jarfile and jarentry (path in jar file)
  *
  * output;
  *  all files and subdirectories inside jarentry will be extracted to TmpD/mochikit.tmp
  *  we will return the location of /TmpD/mochikit.tmp* so you can reference the files locally
  */
 function extractJarToTmp(jar) {
   var tmpdir = Components.classes["@mozilla.org/file/directory_service;1"]
                       .getService(Components.interfaces.nsIProperties)
                       .get("ProfD", Components.interfaces.nsILocalFile);
   tmpdir.append("mochikit.tmp");
   // parseInt is used because octal escape sequences cause deprecation warnings
   // in strict mode (which is turned on in debug builds)
   tmpdir.createUnique(Components.interfaces.nsIFile.DIRECTORY_TYPE, parseInt("0777", 8));
   var zReader = Components.classes["@mozilla.org/libjar/zip-reader;1"].
                   createInstance(Components.interfaces.nsIZipReader);
   var fileHandler = Components.classes["@mozilla.org/network/protocol;1?name=file"].
                     getService(Components.interfaces.nsIFileProtocolHandler);
   var fileName = fileHandler.getFileFromURLSpec(jar.JARFile.spec);
   zReader.open(fileName);
   //filepath represents the path in the jar file without the filename
   var filepath = "";
   var parts = jar.JAREntry.split('/');
   for (var i =0; i < parts.length - 1; i++) {
     if (parts[i] != '') {
       filepath += parts[i] + '/';
     }
   }
   /* Create dir structure first, no guarantee about ordering of directories and
    * files returned from findEntries.
    */
   var dirs = zReader.findEntries(filepath + '*/');
   while (dirs.hasMore()) {
     var targetDir = buildRelativePath(dirs.getNext(), tmpdir, filepath);
     // parseInt is used because octal escape sequences cause deprecation warnings
     // in strict mode (which is turned on in debug builds)
     if (!targetDir.exists()) {
       targetDir.create(Components.interfaces.nsIFile.DIRECTORY_TYPE, parseInt("0777", 8));
     }
   }
   //now do the files
   var files = zReader.findEntries(filepath + "*");
   while (files.hasMore()) {
     var fname = files.getNext();
     if (fname.substr(-1) != '/') {
       var targetFile = buildRelativePath(fname, tmpdir, filepath);
       zReader.extract(fname, targetFile);
     }
   }
   return tmpdir;
 }
 /*
  * Take a relative path from the current mochitest file
  * and returns the absolute path for the given test data file.
  */
 function getTestFilePath(path) {
   if (path[0] == "/") {
     throw new Error("getTestFilePath only accepts relative path");
   }
   // Get the chrome/jar uri for the current mochitest file
   // gTestPath being defined by the test harness in browser-chrome tests
   // or window is being used for mochitest-browser
   var baseURI = typeof(gTestPath) == "string" ? gTestPath : window.location.href;
   var parentURI = getResolvedURI(getRootDirectory(baseURI));
   var file;
   if (parentURI.JARFile) {
     // If it's a jar/zip, we have to extract it first
     file = extractJarToTmp(parentURI);
   } else {
     // Otherwise, we can directly cast it to a file URI
     var fileHandler = Components.classes["@mozilla.org/network/protocol;1?name=file"].
                       getService(Components.interfaces.nsIFileProtocolHandler);
     file = fileHandler.getFileFromURLSpec(parentURI.spec);
   }
   // Then walk by the given relative path
   path.split("/")
       .forEach(function (p) {
         if (p == "..") {
           file = file.parent;
         } else if (p != ".") {
           file.append(p);
         }
       });
   return file.path;
 }
 /*
  * Simple utility function to take the directory structure in jarentryname and
  * translate that to a path of a nsILocalFile.
  */
 function buildRelativePath(jarentryname, destdir, basepath)
 {
   var baseParts = basepath.split('/');
   if (baseParts[baseParts.length-1] == '') {
     baseParts.pop();
   }
   var parts = jarentryname.split('/');
   var targetFile = Components.classes["@mozilla.org/file/local;1"]
                    .createInstance(Components.interfaces.nsILocalFile);
   targetFile.initWithFile(destdir);
   for (var i = baseParts.length; i < parts.length; i++) {
     targetFile.append(parts[i]);
   }
   return targetFile;
 }
 function readConfig(filename) {
   filename = filename || "testConfig.js";
   var fileLocator = Components.classes["@mozilla.org/file/directory_service;1"].
                     getService(Components.interfaces.nsIProperties);
   var configFile = fileLocator.get("ProfD", Components.interfaces.nsIFile);
   configFile.append(filename);
   if (!configFile.exists())
     return {};
   var fileInStream = Components.classes["@mozilla.org/network/file-input-stream;1"].
                      createInstance(Components.interfaces.nsIFileInputStream);
   fileInStream.init(configFile, -1, 0, 0);
   var str = NetUtil.readInputStreamToString(fileInStream, fileInStream.available());
   fileInStream.close();
   return JSON.parse(str);
 }
 function registerTests() {
   var testsURI = Components.classes["@mozilla.org/file/directory_service;1"].
                  getService(Components.interfaces.nsIProperties).
                  get("ProfD", Components.interfaces.nsILocalFile);
   testsURI.append("tests.manifest");
   var ioSvc = Components.classes["@mozilla.org/network/io-service;1"].
               getService(Components.interfaces.nsIIOService);
   var manifestFile = ioSvc.newFileURI(testsURI).
                      QueryInterface(Components.interfaces.nsIFileURL).file;
   Components.manager.QueryInterface(Components.interfaces.nsIComponentRegistrar).
                      autoRegister(manifestFile);
 }
 function getTestList(params, callback) {
   registerTests();
   var baseurl = 'chrome://mochitests/content';
   if (window.parseQueryString) {
     params = parseQueryString(location.search.substring(1), true);
   }
   if (!params.baseurl) {
     params.baseurl = baseurl;
   }
   var config = readConfig();
   for (var p in params) {
     if (params[p] == 1) {
       config[p] = true;
     } else if (params[p] == 0) {
       config[p] = false;
     } else {
       config[p] = params[p];
     }
   }
   params = config;
   if (params.manifestFile) {
     getTestManifest("http://mochi.test:8888/" + params.manifestFile, params, callback);
     return;
   }
   var links = {};
   // load server.js in so we can share template functions
   var scriptLoader = Cc["@mozilla.org/moz/jssubscript-loader;1"].
                        getService(Ci.mozIJSSubScriptLoader);
   var srvScope = {};
   scriptLoader.loadSubScript('chrome://mochikit/content/server.js',
                              srvScope);
   if (getResolvedURI(baseurl).JARFile) {
     links = getMochitestJarListing(baseurl, params.testPath, params.testRoot);
   } else {
     links = getFileListing(baseurl, params.testPath, params.testRoot, srvScope);
   }
   callback(links);
 }