The Tor Browser: comparison testing/mochitest/chrome-harness.js

comparison: testing/mochitest/chrome-harness.js

testing/mochitest/chrome-harness.js

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:85c76df66651
+/* -*- 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);
+}