diff options
Diffstat (limited to 'infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/drivers/JsDriver.java')
-rw-r--r-- | infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/drivers/JsDriver.java | 838 |
1 files changed, 838 insertions, 0 deletions
diff --git a/infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/drivers/JsDriver.java b/infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/drivers/JsDriver.java new file mode 100644 index 0000000..8bae79f --- /dev/null +++ b/infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/drivers/JsDriver.java @@ -0,0 +1,838 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is the Java port of jsDriver.pl. + * + * The Initial Developer of the Original Code is + * David P. Caldwell. + * Portions created by David P. Caldwell are Copyright (C) + * 2007 David P. Caldwell. All Rights Reserved. + * + * + * Contributor(s): + * David P. Caldwell <inonit@inonit.com> + * Norris Boyd <norrisboyd@gmail.com> + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript.drivers; + +import java.io.*; +import java.util.*; + +import org.w3c.dom.*; + +import org.mozilla.javascript.tools.shell.*; + +/** + * @version $Id: JsDriver.java,v 1.5 2007/10/11 19:44:10 szegedia%freemail.hu Exp $ + */ +public class JsDriver { + private JsDriver() { + } + + private static String join(String[] list) { + String rv = ""; + for (int i=0; i<list.length; i++) { + rv += list[i]; + if (i+1 != list.length) { + rv += ","; + } + } + return rv; + } + + private static class Tests { + private File testDirectory; + private String[] list; + private String[] skip; + + Tests(File testDirectory, String[] list, String[] skip) { + this.testDirectory = testDirectory; + this.list = getTestList(list); + this.skip = getTestList(skip); + } + + private String[] getTestList(String[] tests) { + ArrayList list = new ArrayList(); + for (int i=0; i < tests.length; i++) { + if (tests[i].startsWith("@")) + addTestsFromFile(tests[i].substring(1), list); + else + list.add(tests[i]); + } + return (String[])list.toArray(new String[0]); + } + + private void addTestsFromFile(String filename, ArrayList list) { + try { + Properties props = new Properties(); + props.load(new FileInputStream(new File(filename))); + list.addAll(props.keySet()); + } catch (IOException e) { + throw new RuntimeException("Could not read file '" + filename + "'", e); + } + } + + private boolean matches(String[] patterns, String path) { + for (int i=0; i<patterns.length; i++) { + if (path.startsWith(patterns[i])) { + return true; + } + } + return false; + } + + private boolean matches(String path) { + if (list.length == 0) return true; + return matches(list, path); + } + + private boolean excluded(String path) { + if (skip.length == 0) return false; + return matches(skip, path); + } + + private void addFiles(List rv, String prefix, File directory) { + File[] files = directory.listFiles(); + if (files == null) throw new RuntimeException("files null for " + directory); + for (int i=0; i<files.length; i++) { + String path = prefix + files[i].getName(); + if (ShellTest.DIRECTORY_FILTER.accept(files[i])) { + addFiles(rv, path + "/", files[i]); + } else { + boolean isTopLevel = prefix.length() == 0; + if (ShellTest.TEST_FILTER.accept(files[i]) && matches(path) && !excluded(path) && !isTopLevel) { + rv.add(new Script(path, files[i])); + } + } + } + } + + static class Script { + private String path; + private File file; + + Script(String path, File file) { + this.path = path; + this.file = file; + } + + String getPath() { + return path; + } + + File getFile() { + return file; + } + } + + Script[] getFiles() { + ArrayList rv = new ArrayList(); + addFiles(rv, "", testDirectory); + return (Script[])rv.toArray(new Script[0]); + } + } + + private static class ConsoleStatus extends ShellTest.Status { + private File jsFile; + + private Arguments.Console console; + private boolean trace; + + private boolean failed; + + ConsoleStatus(Arguments.Console console, boolean trace) { + this.console = console; + this.trace = trace; + } + + void running(File jsFile) { + try { + console.println("Running: " + jsFile.getCanonicalPath()); + this.jsFile = jsFile; + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + void failed(String s) { + console.println("Failed: " + jsFile + ": " + s); + failed = true; + } + + void threw(Throwable t) { + console.println("Failed: " + jsFile + " with exception."); + console.println(ShellTest.getStackTrace(t)); + failed = true; + } + + void timedOut() { + console.println("Failed: " + jsFile + ": timed out."); + failed = true; + } + + void exitCodesWere(int expected, int actual) { + if (expected != actual) { + console.println("Failed: " + jsFile + " expected " + expected + " actual " + actual); + failed = true; + } + } + + void outputWas(String s) { + if (!failed) { + console.println("Passed: " + jsFile); + if (trace) { + console.println(s); + } + } + } + } + + // returns true if node was found, false otherwise + private static boolean setContent(Element node, String id, String content) { + if (node.getAttribute("id").equals(id)) { + node.setTextContent(node.getTextContent() + "\n" + content); + return true; + } else { + NodeList children = node.getChildNodes(); + for (int i=0; i<children.getLength(); i++) { + if (children.item(i) instanceof Element) { + Element e = (Element)children.item(i); + boolean rv = setContent( e, id, content ); + if (rv) { + return true; + } + } + } + } + return false; + } + + private static Element getElementById(Element node, String id) { + if (node.getAttribute("id").equals(id)) { + return node; + } else { + NodeList children = node.getChildNodes(); + for (int i=0; i<children.getLength(); i++) { + if (children.item(i) instanceof Element) { + Element rv = getElementById( (Element)children.item(i), id ); + if (rv != null) { + return rv; + } + } + } + } + return null; + } + + private static String newlineLineEndings(String s) { + StringBuffer rv = new StringBuffer(); + for (int i=0; i<s.length(); i++) { + if (s.charAt(i) == '\r') { + if (i+1<s.length() && s.charAt(i+1) == '\n') { + // just skip \r + } else { + // Macintosh, substitute \n + rv.append('\n'); + } + } else { + rv.append(s.charAt(i)); + } + } + return rv.toString(); + } + + private static class HtmlStatus extends ShellTest.Status { + private String testPath; + private String bugUrl; + private String lxrUrl; + private Document html; + private Element failureHtml; + private boolean failed; + + private String output; + + HtmlStatus(String lxrUrl, String bugUrl, String testPath, Document html, Element failureHtml) { + this.testPath = testPath; + this.bugUrl = bugUrl; + this.lxrUrl = lxrUrl; + this.html = html; + this.failureHtml = failureHtml; + } + + void running(File file) { + } + + void failed(String s) { + failed = true; + setContent(failureHtml, "failureDetails.reason", "Failure reason: \n" + s); + } + + void exitCodesWere(int expected, int actual) { + if (expected != actual) { + failed = true; + setContent(failureHtml, "failureDetails.reason", "expected exit code " + expected + " but got " + actual); + } + } + + void threw(Throwable e) { + failed = true; + setContent(failureHtml, "failureDetails.reason", "Threw Java exception:\n" + newlineLineEndings(ShellTest.getStackTrace(e))); + } + + void timedOut() { + failed = true; + setContent(failureHtml, "failureDetails.reason", "Timed out."); + } + + void outputWas(String s) { + this.output = s; + } + + private String getLinesStartingWith(String prefix) { + BufferedReader r = new BufferedReader(new StringReader(output)); + String line = null; + String rv = ""; + try { + while( (line = r.readLine()) != null ) { + if (line.startsWith(prefix)) { + if (rv.length() > 0) { + rv += "\n"; + } + rv += line; + } + } + return rv; + } catch (IOException e) { + throw new RuntimeException("Can't happen."); + } + } + + boolean failed() { + return failed; + } + + void finish() { + if (failed) { + getElementById(failureHtml, "failureDetails.status").setTextContent(getLinesStartingWith("STATUS:")); + + String bn = getLinesStartingWith("BUGNUMBER:"); + Element bnlink = getElementById(failureHtml, "failureDetails.bug.href"); + if (bn.length() > 0) { + String number = bn.substring("BUGNUMBER: ".length()); + if (!number.equals("none")) { + bnlink.setAttribute("href", bugUrl + number); + getElementById(bnlink, "failureDetails.bug.number").setTextContent(number); + } else { + bnlink.getParentNode().removeChild(bnlink); + } + } else { + bnlink.getParentNode().removeChild(bnlink); + } + + getElementById(failureHtml, "failureDetails.lxr").setAttribute("href", lxrUrl + testPath); + getElementById(failureHtml, "failureDetails.lxr.text").setTextContent(testPath); + + getElementById(html.getDocumentElement(), "retestList.text").setTextContent( + getElementById(html.getDocumentElement(), "retestList.text").getTextContent() + + testPath + + "\n" + ); + + getElementById(html.getDocumentElement(), "failureDetails").appendChild(failureHtml); + } + } + } + + private static class XmlStatus extends ShellTest.Status { + private Element target; + private Date start; + + XmlStatus(String path, Element root) { + this.target = root.getOwnerDocument().createElement("test"); + this.target.setAttribute("path", path); + root.appendChild(target); + } + + void running(File file) { + this.start = new Date(); + } + + private Element createElement(Element parent, String name) { + Element rv = parent.getOwnerDocument().createElement(name); + parent.appendChild(rv); + return rv; + } + + private void finish() { + Date end = new Date(); + long elapsed = end.getTime() - start.getTime(); + this.target.setAttribute("elapsed", String.valueOf(elapsed)); + } + + private void setTextContent(Element e, String content) { + e.setTextContent( newlineLineEndings(content) ); + } + + void exitCodesWere(int expected, int actual) { + finish(); + Element exit = createElement(target, "exit"); + exit.setAttribute("expected", String.valueOf(expected)); + exit.setAttribute("actual", String.valueOf(actual)); + } + + void timedOut() { + finish(); + createElement(target, "timedOut"); + } + + void failed(String s) { + finish(); + Element failed = createElement(target, "failed"); + setTextContent(failed, s); + } + + void outputWas(String message) { + finish(); + Element output = createElement(target, "output"); + setTextContent(output, message); + } + + void threw(Throwable t) { + finish(); + Element threw = createElement(target, "threw"); + setTextContent(threw, ShellTest.getStackTrace(t)); + } + } + + private static class Results { + private ShellContextFactory factory; + private Arguments arguments; + private File output; + private boolean trace; + + private Document html; + private Element failureHtml; + + private Document xml; + + private Date start; + private int tests; + private int failures; + + Results(ShellContextFactory factory, Arguments arguments, boolean trace) { + this.factory = factory; + this.arguments = arguments; + + File output = arguments.getOutputFile(); + if (output == null) { + output = new File("rhino-test-results." + new java.text.SimpleDateFormat("yyyy.MM.dd.HH.mm.ss").format(new Date()) + ".html"); + } + this.output = output; + + this.trace = trace; + } + + private Document parse(InputStream in) { + try { + javax.xml.parsers.DocumentBuilderFactory factory = javax.xml.parsers.DocumentBuilderFactory.newInstance(); + factory.setValidating(false); + javax.xml.parsers.DocumentBuilder dom = factory.newDocumentBuilder(); + return dom.parse(in); + } catch (Throwable t) { + throw new RuntimeException("Parser failure", t); + } + } + + private Document getTemplate() { + return parse(getClass().getResourceAsStream("results.html")); + } + + private void write(Document template, boolean xml) { + try { + File output = this.output; + javax.xml.transform.TransformerFactory factory = javax.xml.transform.TransformerFactory.newInstance(); + javax.xml.transform.Transformer xform = factory.newTransformer(); + if (xml) { + xform.setOutputProperty(javax.xml.transform.OutputKeys.METHOD, "xml"); + xform.setOutputProperty(javax.xml.transform.OutputKeys.OMIT_XML_DECLARATION, "yes"); + output = new File(output.getCanonicalPath() + ".xml"); + } + xform.transform( + new javax.xml.transform.dom.DOMSource(template), + new javax.xml.transform.stream.StreamResult( new FileOutputStream(output) ) + ); + } catch (IOException e) { + arguments.getConsole().println("Could not write results file to " + output + ": "); + e.printStackTrace(System.err); + } catch (javax.xml.transform.TransformerConfigurationException e) { + throw new RuntimeException("Parser failure", e); + } catch (javax.xml.transform.TransformerException e) { + throw new RuntimeException("Parser failure", e); + } + } + + void start() { + this.html = getTemplate(); + this.failureHtml = getElementById(html.getDocumentElement(), "failureDetails.prototype"); + if (this.failureHtml == null) { + try { + javax.xml.transform.TransformerFactory.newInstance().newTransformer().transform( + new javax.xml.transform.dom.DOMSource(html), + new javax.xml.transform.stream.StreamResult(System.err) + ); + } catch (Throwable t) { + throw new RuntimeException(t); + } + throw new RuntimeException("No"); + } + this.failureHtml.getParentNode().removeChild(this.failureHtml); + + try { + this.xml = javax.xml.parsers.DocumentBuilderFactory.newInstance().newDocumentBuilder() + .getDOMImplementation().createDocument(null, "results", null) + ; + xml.getDocumentElement().setAttribute("timestamp", String.valueOf(new Date().getTime())); + xml.getDocumentElement().setAttribute("optimization", String.valueOf(arguments.getOptimizationLevel())); + xml.getDocumentElement().setAttribute("strict", String.valueOf(arguments.isStrict())); + xml.getDocumentElement().setAttribute("timeout", String.valueOf(arguments.getTimeout())); + } catch (javax.xml.parsers.ParserConfigurationException e) { + throw new RuntimeException(e); + } + + this.start = new Date(); + } + + void run(Tests.Script script, ShellTest.Parameters parameters) { + String path = script.getPath(); + File test = script.getFile(); + ConsoleStatus cStatus = new ConsoleStatus(arguments.getConsole(), trace); + HtmlStatus hStatus = new HtmlStatus(arguments.getLxrUrl(), arguments.getBugUrl(), path, html, (Element)failureHtml.cloneNode(true)); + XmlStatus xStatus = new XmlStatus(path, this.xml.getDocumentElement()); + ShellTest.Status status = ShellTest.Status.compose(new ShellTest.Status[] { cStatus, hStatus, xStatus }); + try { + ShellTest.run(factory, test, parameters, status); + } catch (Exception e) { + throw new RuntimeException(e); + } + tests++; + if (hStatus.failed()) { + failures++; + } + hStatus.finish(); + } + + private void set(Document document, String id, String value) { + getElementById(document.getDocumentElement(), id).setTextContent(value); + } + + void finish() { + Date end = new Date(); + long elapsedMs = end.getTime() - start.getTime(); + set(html, "results.testlist", join(arguments.getTestList())); + set(html, "results.skiplist", join(arguments.getSkipList())); + String pct = new java.text.DecimalFormat("##0.00").format( (double)failures / (double)tests * 100.0 ); + set(html, "results.results", "Tests attempted: " + tests + " Failures: " + failures + " (" + pct + "%)"); + set(html, "results.platform", "java.home=" + System.getProperty("java.home") + + "\n" + "java.version=" + System.getProperty("java.version") + + "\n" + "os.name=" + System.getProperty("os.name") + ); + set(html, "results.classpath", System.getProperty("java.class.path").replace(File.pathSeparatorChar, ' ')); + int elapsedSeconds = (int)(elapsedMs / 1000); + int elapsedMinutes = elapsedSeconds / 60; + elapsedSeconds = elapsedSeconds % 60; + String elapsed = "" + elapsedMinutes + " minutes, " + elapsedSeconds + " seconds"; + set(html, "results.elapsed", elapsed); + set(html, "results.time", new java.text.SimpleDateFormat("MMMM d yyyy h:mm:ss aa").format(new java.util.Date())); + write(html, false); + write(xml, true); + } + } + + private static class ShellTestParameters extends ShellTest.Parameters { + private int timeout; + + ShellTestParameters(int timeout) { + this.timeout = timeout; + } + + int getTimeoutMilliseconds() { + return timeout; + } + } + + void run(Arguments arguments) throws Throwable { + if (arguments.help()) { + System.out.println("See mozilla/js/tests/README-jsDriver.html; note that some options are not supported."); + System.out.println("Consult the Java source code at testsrc/org/mozilla/javascript/JsDriver.java for details."); + System.exit(0); + } + + ShellContextFactory factory = new ShellContextFactory(); + factory.setOptimizationLevel(arguments.getOptimizationLevel()); + factory.setStrictMode(arguments.isStrict()); + + File path = arguments.getTestsPath(); + if (path == null) { + path = new File("../tests"); + } + if (!path.exists()) { + throw new RuntimeException("JavaScript tests not found at " + path.getCanonicalPath()); + } + Tests tests = new Tests(path, arguments.getTestList(), arguments.getSkipList()); + Tests.Script[] all = tests.getFiles(); + arguments.getConsole().println("Running " + all.length + " tests."); + + Results results = new Results(factory, arguments, arguments.trace()); + + results.start(); + for (int i=0; i<all.length; i++) { + results.run(all[i], new ShellTestParameters(arguments.getTimeout())); + } + results.finish(); + } + + public static void main(Arguments arguments) throws Throwable { + JsDriver driver = new JsDriver(); + driver.run(arguments); + } + + private static class Arguments { + private ArrayList options = new ArrayList(); + + private Option bugUrl = new Option("b", "bugurl", false, false, "http://bugzilla.mozilla.org/show_bug.cgi?id="); + private Option optimizationLevel = new Option("o", "optimization", false, false, "-1"); + private Option strict = new Option(null, "strict", false, true, null); + private Option outputFile = new Option("f", "file", false, false, null); + private Option help = new Option("h", "help", false, true, null); + private Option logFailuresToConsole = new Option("k", "confail", false, true, null); + private Option testList = new Option("l", "list", true, false, null); + private Option skipList = new Option("L", "neglist", true, false, null); + private Option testsPath = new Option("p", "testpath", false, false, null); + private Option trace = new Option("t", "trace", false, true, null); + private Option lxrUrl = new Option("u", "lxrurl", false, false, "http://lxr.mozilla.org/mozilla/source/js/tests/"); + private Option timeout = new Option(null, "timeout", false, false, "60000"); + + public static class Console { + public void print(String message) { + System.out.print(message); + } + public void println(String message) { + System.out.println(message); + } + } + private Console console = new Console(); + + private class Option { + private String letterOption; + private String wordOption; + private boolean array; + private boolean flag; + private boolean ignored; + + private ArrayList values = new ArrayList(); + + // array: can this option have multiple values? + // flag: is this option a simple true/false switch? + Option(String letterOption, String wordOption, boolean array, boolean flag, String unspecified) { + this.letterOption = letterOption; + this.wordOption = wordOption; + this.flag = flag; + this.array = array; + if (!flag && !array) { + this.values.add(unspecified); + } + options.add(this); + } + + Option ignored() { + this.ignored = true; + return this; + } + + int getInt() { + return Integer.parseInt( getValue() ); + } + + String getValue() { + return (String)values.get(0); + } + + boolean getSwitch() { + return values.size() > 0; + } + + File getFile() { + if (getValue() == null) return null; + return new File(getValue()); + } + + String[] getValues() { + return (String[])values.toArray(new String[0]); + } + + void process(List arguments) { + String option = (String)arguments.get(0); + String dashLetter = (letterOption == null) ? (String)null : "-" + letterOption; + if (option.equals(dashLetter) || option.equals("--" + wordOption)) { + arguments.remove(0); + if (flag) { + values.add(0, (String)null ); + } else if (array) { + while( arguments.size() > 0 && !( (String)arguments.get(0) ).startsWith("-") ) { + values.add(arguments.remove(0)); + } + } else { + values.set(0, arguments.remove(0)); + } + if (ignored) { + System.err.println("WARNING: " + option + " is ignored in the Java version of the test driver."); + } + } + } + } + + // -b URL, --bugurl=URL + public String getBugUrl() { + return bugUrl.getValue(); + } + + // -c PATH, --classpath=PATH + // Does not apply; we will use the VM's classpath + + // -e TYPE ..., --engine=TYPE ... + // Does not apply; was used to select between SpiderMonkey and Rhino + + // Not in jsDriver.pl + public int getOptimizationLevel() { + return optimizationLevel.getInt(); + } + + // --strict + public boolean isStrict() { + return strict.getSwitch(); + } + + // -f FILE, --file=FILE + public File getOutputFile() { + return outputFile.getFile(); + } + + // -h, --help + public boolean help() { + return help.getSwitch(); + } + + // -j PATH, --javapath=PATH + // Does not apply; we will use this JVM + + // -k, --confail + // TODO Currently this is ignored; not clear precisely what it means (perhaps we should not be logging ordinary + // pass/fail to the console currently?) + public boolean logFailuresToConsole() { + return logFailuresToConsole.getSwitch(); + } + + // -l FILE,... or --list=FILE,... + public String[] getTestList() { + return testList.getValues(); + } + + // -L FILE,... or --neglist=FILE,... + public String[] getSkipList() { + return skipList.getValues(); + } + + // -p PATH, --testpath=PATH + public File getTestsPath() { + return testsPath.getFile(); + } + + // -s PATH, --shellpath=PATH + // Does not apply; we will use the Rhino shell with any classes given on the classpath + + // -t, --trace + public boolean trace() { + return trace.getSwitch(); + } + + // -u URL, --lxrurl=URL + public String getLxrUrl() { + return lxrUrl.getValue(); + } + + // + // New arguments + // + + // --timeout + // Milliseconds to wait for each test + public int getTimeout() { + return timeout.getInt(); + } + + public Console getConsole() { + return console; + } + + void process(List arguments) { + while(arguments.size() > 0) { + String option = (String)arguments.get(0); + if (option.startsWith("--")) { + // preprocess --name=value options into --name value + if (option.indexOf("=") != -1) { + arguments.set(0, option.substring(option.indexOf("="))); + arguments.add(1, option.substring(option.indexOf("=") + 1)); + } + } else if (option.startsWith("-")) { + // could be multiple single-letter options, e.g. -kht, so preprocess them into -k -h -t + if (option.length() > 2) { + for (int i=2; i<option.length(); i++) { + arguments.add(1, "-" + option.substring(i,i+1)); + } + arguments.set(0, option.substring(0,2)); + } + } + int lengthBefore = arguments.size(); + for (int i=0; i<options.size(); i++) { + if (arguments.size() > 0) { + ((Option)options.get(i)).process(arguments); + } + } + + if (arguments.size() == lengthBefore) { + System.err.println("WARNING: ignoring unrecognized option " + arguments.remove(0)); + } + } + } + } + + public static void main(String[] args) throws Throwable { + ArrayList arguments = new ArrayList(); + arguments.addAll(Arrays.asList(args)); + Arguments clArguments = new Arguments(); + clArguments.process(arguments); + main(clArguments); + } +} |