mirror of https://github.com/tc39/test262.git
Adapted the sputnik command line testRunner to a command line
testRunner, test262.py, that can run all the converted tests.
This commit is contained in:
Mark Miller
parent
d0f40b63a2
commit
a2ca5b512b
|
|
@ -0,0 +1,90 @@
|
|||
// Copyright 2009 the Sputnik authors. All rights reserved.
|
||||
// This code is governed by the BSD license found in the LICENSE file.
|
||||
|
||||
function Test262Error(message) {
|
||||
this.message = message;
|
||||
}
|
||||
|
||||
Test262Error.prototype.toString = function () {
|
||||
return "Test262 Error: " + this.message;
|
||||
};
|
||||
|
||||
function testFailed(message) {
|
||||
throw new Test262Error(message);
|
||||
}
|
||||
|
||||
function testPrint(message) {
|
||||
|
||||
}
|
||||
|
||||
function $PRINT(message) {
|
||||
testPrint(message);
|
||||
}
|
||||
function $INCLUDE(message) { }
|
||||
function $ERROR(message) {
|
||||
testFailed(message);
|
||||
}
|
||||
function $FAIL(message) {
|
||||
testFailed(message);
|
||||
}
|
||||
|
||||
/**
|
||||
* It is not yet clear that runTestCase should pass the global object
|
||||
* as the 'this' binding in the call to testcase.
|
||||
*/
|
||||
var runTestCase = (function(global) {
|
||||
return function(testcase) {
|
||||
if (!testcase.call(global)) {
|
||||
testFailed('test function returned falsy');
|
||||
}
|
||||
};
|
||||
})(this);
|
||||
|
||||
function assertTruthy(value) {
|
||||
if (!value) {
|
||||
testFailed('test return falsy');
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* falsy means we expect no error.
|
||||
* truthy means we expect some error.
|
||||
* A non-empty string means we expect an error whose .name is that string.
|
||||
*/
|
||||
var expectedErrorName = false;
|
||||
|
||||
/**
|
||||
* What was thrown, or the string 'Falsy' if something falsy was thrown.
|
||||
* null if test completed normally.
|
||||
*/
|
||||
var actualError = null;
|
||||
|
||||
function testStarted(expectedErrName) {
|
||||
expectedErrorName = expectedErrName;
|
||||
}
|
||||
|
||||
function testFinished() {
|
||||
var actualErrorName = actualError && (actualError.name ||
|
||||
'SomethingThrown');
|
||||
if (actualErrorName) {
|
||||
if (expectedErrorName) {
|
||||
if (typeof expectedErrorName === 'string') {
|
||||
if (expectedErrorName === actualErrorName) {
|
||||
return;
|
||||
}
|
||||
testFailed('Threw ' + actualErrorName +
|
||||
' instead of ' + expectedErrorName);
|
||||
}
|
||||
return;
|
||||
}
|
||||
throw actualError;
|
||||
}
|
||||
if (expectedErrorName) {
|
||||
if (typeof expectedErrorName === 'string') {
|
||||
testFailed('Completed instead of throwing ' +
|
||||
expectedErrorName);
|
||||
}
|
||||
testFailed('Completed instead of throwing');
|
||||
}
|
||||
}
|
||||
|
|
@ -2,16 +2,16 @@
|
|||
// Copyright 2009 the Sputnik authors. All rights reserved.
|
||||
// This code is governed by the BSD license found in the LICENSE file.
|
||||
|
||||
function SputnikError(message) {
|
||||
function Test262Error(message) {
|
||||
if (message) this.message = message;
|
||||
}
|
||||
|
||||
SputnikError.prototype.toString = function () {
|
||||
Test262Error.prototype.toString = function () {
|
||||
return "Test262 Error: " + this.message;
|
||||
};
|
||||
|
||||
function testFailed(message) {
|
||||
throw new SputnikError(message);
|
||||
throw new Test262Error(message);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@
|
|||
/// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
//Simple Test APIs
|
||||
var SimpleTestAPIs = []
|
||||
var SimpleTestAPIs = [];
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
function compareArray(aExpected, aActual) {
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ function BrowserRunner() {
|
|||
currentTest.error = "Failed to Load";
|
||||
} else if(typeof currentTest.error !== "undefined") {
|
||||
// We have an error logged from testRun.
|
||||
if(currentTest.error instanceof SputnikError) {
|
||||
if(currentTest.error instanceof Test262Error) {
|
||||
currentTest.error = currentTest.message;
|
||||
} else {
|
||||
currentTest.error = currentTest.error.name + ": " + currentTest.error.message;
|
||||
|
|
@ -96,7 +96,7 @@ function BrowserRunner() {
|
|||
win.testFinished = testFinished;
|
||||
|
||||
//TODO: these should be moved to sta.js
|
||||
win.SputnikError = SputnikError;
|
||||
win.Test262Error = Test262Error;
|
||||
win.$ERROR = $ERROR;
|
||||
win.$FAIL = $FAIL;
|
||||
win.$PRINT = function () {};
|
||||
|
|
|
|||
|
|
@ -32,61 +32,36 @@
|
|||
|
||||
var platform = global.t262.platform = {};
|
||||
|
||||
/**
|
||||
* Appends a bunch of RegExps together into a single RegExp,
|
||||
* solving both the RegExp-one-liner problem and the doubled
|
||||
* backslash problem when composing literal strings.
|
||||
*
|
||||
* <p>The arguments can be any mixture of RegExps and strings. By
|
||||
* expressing the portions that should be well formed regexps as
|
||||
* regexps, we catch well-formedness errors within such a portion
|
||||
* separately. The strings are added as is without escaping --
|
||||
* BEWARE. By not escaping the strings, we can use them to
|
||||
* represent the individually unbalanced fragments, like capturing
|
||||
* parens, around other regexps. If arguments[0] is a RegExp, we
|
||||
* use its flags on the resuting RegExp.
|
||||
*
|
||||
* <p>Not platform dependent, so does not really belong in this
|
||||
* file.
|
||||
*
|
||||
* <p>TODO(erights): must rewrite to avoid depending on anything
|
||||
* not in ES3+Reality.
|
||||
*/
|
||||
function regExp(var_args) {
|
||||
var args = [].slice.call(arguments, 0);
|
||||
var reSrc = args.map(function(arg) {
|
||||
return (typeof arg === 'string') ? arg : arg.source;
|
||||
}).join('');
|
||||
var flags = '';
|
||||
if (typeof args[0] === 'object') {
|
||||
var parts = (''+args[0]).split('/');
|
||||
flags = parts[parts.length -1];
|
||||
}
|
||||
return new RegExp(reSrc, flags);
|
||||
}
|
||||
platform.regExp = regExp;
|
||||
var utils = global.t262.utils;
|
||||
var forEach = utils.forEach;
|
||||
var map = utils.map;
|
||||
|
||||
////////////////// Needed for building and running //////////////
|
||||
// Someday this will be https:
|
||||
var ABS_ROOT_STR = 'http://test262.ecmascript.org/';
|
||||
|
||||
var TEST262_ROOT_STR = ABSOLUTE_PATHSTR ? ABS_ROOT : '';
|
||||
|
||||
// Someday these will be https:
|
||||
var ABS_ROOT = ['http://test262.ecmascript.org'];
|
||||
var HARNESS_DIR = ['resources', 'scripts', 'global'];
|
||||
platform.HARNESS_DIR = HARNESS_DIR;
|
||||
|
||||
var TEST262_ROOT = ABSOLUTE_PATHSTR ? ABS_ROOT : ['http:'];
|
||||
var CONVERTER_DIR = ['resources', 'scripts', 'global'];
|
||||
platform.CONVERTER_DIR = CONVERTER_DIR;
|
||||
|
||||
var TEST262_ROOT_STR = TEST262_ROOT.join('/');
|
||||
var PLATFORM_PATHS = [
|
||||
HARNESS_DIR.concat('jquery-1.4.2.min.js'),
|
||||
CONVERTER_DIR.concat('utils.js'),
|
||||
CONVERTER_DIR.concat('v8PosixPlatform.js')
|
||||
];
|
||||
platform.PLATFORM_PATHS = PLATFORM_PATHS;
|
||||
|
||||
var CONVERTER_PATH = ['resources', 'scripts', 'global'];
|
||||
platform.CONVERTER_PATH = CONVERTER_PATH;
|
||||
|
||||
var ME_PATH = CONVERTER_PATH.concat('browserPlatform.js');
|
||||
////////////////// Needed for building and running tests //////////////
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
function validatePath(path) {
|
||||
var pathStr = path.join('/');
|
||||
path.forEach(function(segment) {
|
||||
forEach(path, function(segment) {
|
||||
if (segment === '') {
|
||||
throw new Error('A path cannot have empty segments: ' + pathStr);
|
||||
}
|
||||
|
|
@ -122,7 +97,7 @@
|
|||
*/
|
||||
function toPathStr(path) {
|
||||
validatePath(path);
|
||||
return TEST262_ROOT.concat(path).join('/');
|
||||
return TEST262_ROOT_STR + path.join('/');
|
||||
}
|
||||
platform.toPathStr = toPathStr;
|
||||
|
||||
|
|
@ -130,17 +105,22 @@
|
|||
* Returns the text found at path, with newlines normalized and
|
||||
* any initial BOM (Unicode Byte Order Mark) removed.
|
||||
*
|
||||
* Note: Don't simply revise this (without renamings) to follow the
|
||||
* general pattern of also defining a local 'read' function, as it
|
||||
* will mask the v8 shell's read function, which we use.
|
||||
* <p>Note that sync remote reading is a terrible idea, but that
|
||||
* the way test262 was designed and it's hard to change after the
|
||||
* fact.
|
||||
*/
|
||||
platform.read = function(path) {
|
||||
var text = "TBD".
|
||||
replace(/\r\n/g, '\n').
|
||||
replace(/\r/g, '\n');
|
||||
function getText(path) {
|
||||
var text;
|
||||
$.ajax({
|
||||
async: false,
|
||||
url: toPathStr(path),
|
||||
success: function(s) { text = s; }
|
||||
});
|
||||
text = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
|
||||
if (text.charCodeAt(0) === 0xfeff) { return text.substring(1); }
|
||||
return text;
|
||||
};
|
||||
}
|
||||
platform.getText = getText;
|
||||
|
||||
/**
|
||||
* How one JavaScript script possibly spawns another and possibly
|
||||
|
|
@ -185,7 +165,7 @@
|
|||
platform.writeSpawn = writeSpawn;
|
||||
|
||||
|
||||
////////////////// Only needed for running //////////////////////
|
||||
////////////////// Only needed for running tests //////////////////////
|
||||
|
||||
|
||||
})(this);
|
||||
|
|
|
|||
|
|
@ -169,12 +169,12 @@
|
|||
|
||||
var cebMatch = captureExprBodyPattern.exec(body);
|
||||
if (cebMatch) {
|
||||
return 'assertTrue(' + trim(cebMatch[1]) + ');';
|
||||
return 'assertTruthy(' + trim(cebMatch[1]) + ');';
|
||||
}
|
||||
|
||||
var cpMatch = capturePredicatePattern.exec(body);
|
||||
if (cpMatch) {
|
||||
return 'assertTrue(' + trim(cpMatch[1]) + ');';
|
||||
return 'assertTruthy(' + trim(cpMatch[1]) + ');';
|
||||
}
|
||||
|
||||
// General case
|
||||
|
|
@ -324,9 +324,9 @@
|
|||
if (pname in testRecord) {
|
||||
result += ' * @' + pname;
|
||||
if (testRecord[pname]) {
|
||||
result += ': ' + testRecord[pname].replace(/\n/g, '\n * ');
|
||||
result += ' ' + testRecord[pname].replace(/\n/g, '\n * ');
|
||||
}
|
||||
result += ';\n';
|
||||
result += '\n';
|
||||
delete testRecord[pname];
|
||||
}
|
||||
}
|
||||
|
|
@ -346,8 +346,8 @@
|
|||
t262.formatTestRecord = formatTestRecord;
|
||||
|
||||
/**
|
||||
* Reads the test case at pathStr and returns the source of that
|
||||
* test case converted to canonical test262 style.
|
||||
* Reads the test case at inBaseStr+relPathStr and returns the
|
||||
* source of that test case converted to canonical test262 style.
|
||||
*/
|
||||
function convertTest(inBaseStr, relPathStr) {
|
||||
var inBase = toPath(inBaseStr);
|
||||
|
|
@ -420,15 +420,17 @@
|
|||
* case section, as would be uploaded to a browser-based test
|
||||
* runner.
|
||||
*/
|
||||
function buildSection(pathStr) {
|
||||
var path = toPath(pathStr);
|
||||
function buildSection(inBaseStr, relPathStr) {
|
||||
var inBase = toPath(inBaseStr);
|
||||
var relPath = platform.toRelPath(relPathStr);
|
||||
var path = inBase.concat(relPath);
|
||||
if (!platform.isDirectory(path)) { throw new Error('not dir: ' + path); }
|
||||
|
||||
var jsFiles = filter(platform.ls(path), function(name) {
|
||||
return /\.js$/.test(name);
|
||||
});
|
||||
var testRecords = map(jsFiles, function(name) {
|
||||
var testRecord = parseTestRecord(path, name);
|
||||
var testRecord = parseTestRecord(inBase, relPath, name);
|
||||
|
||||
delete testRecord.header;
|
||||
delete testRecord.comment;
|
||||
|
|
@ -468,7 +470,8 @@
|
|||
try {
|
||||
platform.writeSpawn(
|
||||
[CONVERT_PATH],
|
||||
't262.showJSON(t262.buildSection("' + toPathStr(inPath) + '"));',
|
||||
't262.showJSON(t262.buildSection("' + toPathStr(inBase) +
|
||||
'", "' + toRelPathStr(nextRelPath) + '"));',
|
||||
void 0,
|
||||
outFilePath);
|
||||
} catch (err) {
|
||||
|
|
@ -491,10 +494,18 @@
|
|||
*/
|
||||
function buildWebSite(opt_relPathStr) {
|
||||
var relPath = opt_relPathStr ? toRelPath(opt_relPathStr) : [];
|
||||
writeSpawnFailures = [];
|
||||
forEach(CONTRIB_DIRS, function(srcDir) {
|
||||
buildAll(srcDir, OUT_DIR, relPath);
|
||||
});
|
||||
// buildAll(CONVERTED_DIR, OUT_DIR, relPath);
|
||||
if (writeSpawnFailures.length >= 1) {
|
||||
print('********* failures **********');
|
||||
forEach(writeSpawnFailures, function(failure) {
|
||||
print(failure.error + ': ' + toRelPathStr(failure.relPath));
|
||||
});
|
||||
throw writeSpawnFailures[0].error;
|
||||
}
|
||||
}
|
||||
t262.buildWebSite = buildWebSite;
|
||||
|
||||
|
|
|
|||
|
|
@ -121,6 +121,14 @@
|
|||
}
|
||||
platform.getText = getText;
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
function bashQuote(str) {
|
||||
var escaped = JSON.stringify(str).replace(/'/g, "\\'");
|
||||
return "$'" + escaped.substring(1, escaped.length -1) + "'";
|
||||
}
|
||||
|
||||
/**
|
||||
* How one JavaScript script possibly spawns another and possibly
|
||||
* redirects its printed form to a chosen file (or resource).
|
||||
|
|
@ -164,7 +172,9 @@
|
|||
opt_targetPath,
|
||||
opt_spawn_required,
|
||||
opt_forceNonStrict) {
|
||||
if (opt_src && !opt_targetPath && !opt_spawn_required) {
|
||||
if (typeof opt_src === 'string' &&
|
||||
!opt_targetPath &&
|
||||
!opt_spawn_required) {
|
||||
var str = '(function(/*var_args*/) { ';
|
||||
if (opt_forceNonStrict !== 'forceNonStrict') {
|
||||
str += '"use strict"; ';
|
||||
|
|
@ -173,31 +183,52 @@
|
|||
return ''+(1,eval)(str).apply(void 0, opt_args || []);
|
||||
}
|
||||
|
||||
var sys = os.system;
|
||||
if (DRY_RUN) {
|
||||
sys = function(command, args) {
|
||||
print(command + ' ' + args.join(' '));
|
||||
};
|
||||
}
|
||||
|
||||
var allScriptPaths = PLATFORM_PATHS.concat(scriptPaths);
|
||||
var cmd = 'v8 ' + map(allScriptPaths, toPathStr).join(' ');
|
||||
|
||||
if (opt_src) {
|
||||
cmd += ' -e ' + JSON.stringify(opt_src);
|
||||
if (typeof opt_src === 'string') {
|
||||
cmd += ' -e ' + bashQuote(opt_src);
|
||||
}
|
||||
if (opt_args) {
|
||||
cmd += ' -- ' + map(opt_args, JSON.stringify).join(' ');
|
||||
cmd += ' -- ' + map(opt_args, bashQuote).join(' ');
|
||||
}
|
||||
if (opt_targetPath) {
|
||||
cmd += ' > ' + toPathStr(opt_targetPath);
|
||||
}
|
||||
if (VERBOSE || DRY_RUN) { print(cmd); }
|
||||
if (DRY_RUN) { return ''; }
|
||||
|
||||
if (VERBOSE && !DRY_RUN) { print(cmd); }
|
||||
|
||||
// We write the output to a temporary file for two reasons:
|
||||
// * If the spawned script dies with a useful diagnostic,
|
||||
// os.system will throw an error omitting that diagnostic
|
||||
// text. However, bash ">" will both redirect to the output file
|
||||
// and preserve the error code of the command to the left. Bash
|
||||
// does not preserve the error code with "|" redirection.
|
||||
// * If we actually have a target, we only want to write into it
|
||||
// if our command runs successfully.
|
||||
var tempPathStr = os.system('mktemp', ['-t', 'temp.']).trim();
|
||||
cmd += ' > ' + tempPathStr;
|
||||
|
||||
var result;
|
||||
try {
|
||||
return os.system('bash', ['-c', cmd]);
|
||||
try {
|
||||
result = sys('bash', ['-c', cmd]);
|
||||
} catch (err) {
|
||||
if (opt_targetPath) {
|
||||
// The error we catch is almost certainly less interesting
|
||||
// than the one unfortunately written to the target file.
|
||||
var message = 'failed: ' + cmd + '\n' + getText(opt_targetPath);
|
||||
os.system('rm', [toPathStr(opt_targetPath)]);
|
||||
var message = 'failed: ' + cmd + '\n---\n' + read(tempPathStr);
|
||||
throw new Error(message);
|
||||
}
|
||||
throw err;
|
||||
if (opt_targetPath) {
|
||||
sys('cp', [tempPathStr, toPathStr(opt_targetPath)]);
|
||||
}
|
||||
return result;
|
||||
} finally {
|
||||
sys('rm', ['-f', tempPathStr]);
|
||||
}
|
||||
}
|
||||
platform.writeSpawn = writeSpawn;
|
||||
|
|
@ -322,5 +353,16 @@
|
|||
|
||||
////////////////// Only needed for running tests //////////////////////
|
||||
|
||||
if (!global.$PRINT) {
|
||||
global.$PRINT = t262.show;
|
||||
}
|
||||
|
||||
if (!global.$INCLUDE) {
|
||||
global.$INCLUDE = function(name) {
|
||||
// does nothing even locally, since the platform independent
|
||||
// include processing picks these up anyway.
|
||||
// load(toPathStr(HARNESS_DIR.concat([name])));
|
||||
};
|
||||
}
|
||||
|
||||
})(this);
|
||||
|
|
|
|||
|
|
@ -0,0 +1,530 @@
|
|||
#!/usr/bin/python
|
||||
# Copyright 2009 the Sputnik authors. All rights reserved.
|
||||
# This code is governed by the BSD license found in the LICENSE file.
|
||||
|
||||
|
||||
import logging
|
||||
import optparse
|
||||
import os
|
||||
from os import path
|
||||
import platform
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
|
||||
|
||||
class Test262Error(Exception):
|
||||
|
||||
def __init__(self, message):
|
||||
self.message = message
|
||||
|
||||
|
||||
def ReportError(s):
|
||||
raise Test262Error(s)
|
||||
|
||||
|
||||
def BuildOptions():
|
||||
result = optparse.OptionParser()
|
||||
result.add_option("--command", default=None, help="The command-line to run")
|
||||
result.add_option("--tests", default=path.abspath('.'),
|
||||
help="Path to the tests")
|
||||
result.add_option("--cat", default=False, action="store_true",
|
||||
help="Print test source code")
|
||||
result.add_option("--summary", default=False, action="store_true",
|
||||
help="Print summary after running tests")
|
||||
result.add_option("--full-summary", default=False, action="store_true",
|
||||
help="Print summary and test output after running tests")
|
||||
result.add_option("--enable-strict-mode", default=False, action="store_true",
|
||||
help="Run the mode also in ES5 strict mode")
|
||||
|
||||
return result
|
||||
|
||||
|
||||
def ValidateOptions(options):
|
||||
if not options.command:
|
||||
ReportError("A --command must be specified.")
|
||||
if not path.exists(options.tests):
|
||||
ReportError("Couldn't find test path '%s'" % options.tests)
|
||||
|
||||
|
||||
_PLACEHOLDER_PATTERN = re.compile(r"\{\{(\w+)\}\}")
|
||||
_INCLUDE_PATTERN = re.compile(r"\$INCLUDE\(\"(.*)\"\);")
|
||||
_SPECIAL_CALL_PATTERN = re.compile(r"\$([A-Z]+)(?=\()")
|
||||
|
||||
|
||||
_SPECIAL_CALLS = {
|
||||
'ERROR': 'testFailed',
|
||||
'FAIL': 'testFailed',
|
||||
'PRINT': 'testPrint'
|
||||
}
|
||||
|
||||
|
||||
def IsWindows():
|
||||
p = platform.system()
|
||||
return (p == 'Windows') or (p == 'Microsoft')
|
||||
|
||||
|
||||
def StripHeader(str):
|
||||
while str.startswith('//') and "\n" in str:
|
||||
str = str[str.index("\n")+1:]
|
||||
return str.lstrip()
|
||||
|
||||
|
||||
class TempFile(object):
|
||||
|
||||
def __init__(self, suffix="", prefix="tmp", text=False):
|
||||
self.suffix = suffix
|
||||
self.prefix = prefix
|
||||
self.text = text
|
||||
self.fd = None
|
||||
self.name = None
|
||||
self.is_closed = False
|
||||
self.Open()
|
||||
|
||||
def Open(self):
|
||||
(self.fd, self.name) = tempfile.mkstemp(
|
||||
suffix = self.suffix,
|
||||
prefix = self.prefix,
|
||||
text = self.text
|
||||
)
|
||||
|
||||
def Write(self, str):
|
||||
os.write(self.fd, str)
|
||||
|
||||
def Read(self):
|
||||
f = file(self.name)
|
||||
result = f.read()
|
||||
f.close()
|
||||
return result
|
||||
|
||||
def Close(self):
|
||||
if not self.is_closed:
|
||||
self.is_closed = True
|
||||
os.close(self.fd)
|
||||
|
||||
def Dispose(self):
|
||||
try:
|
||||
self.Close()
|
||||
os.unlink(self.name)
|
||||
except OSError, e:
|
||||
logging.error("Error disposing temp file: %s", str(e))
|
||||
|
||||
|
||||
class TestResult(object):
|
||||
|
||||
def __init__(self, exit_code, stdout, stderr, case):
|
||||
self.exit_code = exit_code
|
||||
self.stdout = stdout
|
||||
self.stderr = stderr
|
||||
self.case = case
|
||||
|
||||
def ReportOutcome(self, long_format):
|
||||
name = self.case.GetName()
|
||||
if self.HasUnexpectedOutcome():
|
||||
if self.case.IsNegative():
|
||||
print "%s was expected to fail but didn't" % name
|
||||
elif (self.case.strict_mode and self.case.IsStrictModeNegative()):
|
||||
print "%s was expected to fail in strict mode, but didn't" % name
|
||||
else:
|
||||
if long_format:
|
||||
print "=== %s failed ===" % name
|
||||
else:
|
||||
print "%s: " % name
|
||||
out = self.stdout.strip()
|
||||
if len(out) > 0:
|
||||
print "--- output ---"
|
||||
print out
|
||||
err = self.stderr.strip()
|
||||
if len(err) > 0:
|
||||
print "--- errors ---"
|
||||
print err
|
||||
if long_format:
|
||||
print "==="
|
||||
elif self.case.IsNegative():
|
||||
print "%s failed as expected" % name
|
||||
elif self.case.strict_mode:
|
||||
if self.case.IsStrictModeNegative():
|
||||
print "%s failed in strict mode as expected" % name
|
||||
else:
|
||||
print "%s passed in strict mode" % name
|
||||
else:
|
||||
print "%s passed" % name
|
||||
|
||||
def HasFailed(self):
|
||||
return self.exit_code != 0
|
||||
|
||||
def HasUnexpectedOutcome(self):
|
||||
if self.case.IsNegative():
|
||||
return not self.HasFailed()
|
||||
if self.case.IsStrictModeNegative():
|
||||
return not self.HasFailed()
|
||||
else:
|
||||
return self.HasFailed()
|
||||
|
||||
|
||||
class TestCase(object):
|
||||
|
||||
def __init__(self, suite, name, full_path, strict_mode=False):
|
||||
self.suite = suite
|
||||
self.name = name
|
||||
self.full_path = full_path
|
||||
self.contents = None
|
||||
self.is_negative = None
|
||||
self.strict_mode = strict_mode
|
||||
self.is_strict_mode_negative = None
|
||||
|
||||
def GetName(self):
|
||||
return path.join(*self.name)
|
||||
|
||||
def GetPath(self):
|
||||
return self.name
|
||||
|
||||
def GetRawContents(self):
|
||||
if self.contents is None:
|
||||
f = open(self.full_path)
|
||||
self.contents = f.read()
|
||||
f.close()
|
||||
return self.contents
|
||||
|
||||
def IsNegative(self):
|
||||
if self.is_negative is None:
|
||||
self.is_negative = ("@negative" in self.GetRawContents())
|
||||
return self.is_negative
|
||||
|
||||
def IsStrictModeNegative(self):
|
||||
if self.strict_mode and self.is_strict_mode_negative is None:
|
||||
self.is_strict_mode_negative = \
|
||||
("@strict_mode_negative" in self.GetRawContents())
|
||||
return self.is_strict_mode_negative
|
||||
|
||||
def GetSource(self):
|
||||
source = self.suite.GetInclude("framework.js", False)
|
||||
source += StripHeader(self.GetRawContents())
|
||||
def IncludeFile(match):
|
||||
return self.suite.GetInclude(match.group(1))
|
||||
source = _INCLUDE_PATTERN.sub(IncludeFile, source)
|
||||
def SpecialCall(match):
|
||||
key = match.group(1)
|
||||
return _SPECIAL_CALLS.get(key, match.group(0))
|
||||
if self.strict_mode:
|
||||
source = '"use strict";\nvar strict_mode = true;\n' + \
|
||||
_SPECIAL_CALL_PATTERN.sub(SpecialCall, source)
|
||||
else:
|
||||
source = "var strict_mode = false; \n" + \
|
||||
_SPECIAL_CALL_PATTERN.sub(SpecialCall, source)
|
||||
return source
|
||||
|
||||
def InstantiateTemplate(self, template, params):
|
||||
def GetParameter(match):
|
||||
key = match.group(1)
|
||||
return params.get(key, match.group(0))
|
||||
return _PLACEHOLDER_PATTERN.sub(GetParameter, template)
|
||||
|
||||
def RunTestIn(self, command_template, tmp):
|
||||
tmp.Write(self.GetSource())
|
||||
tmp.Close()
|
||||
command = self.InstantiateTemplate(command_template, {
|
||||
'path': tmp.name
|
||||
})
|
||||
(code, out, err) = self.Execute(command)
|
||||
return TestResult(code, out, err, self)
|
||||
|
||||
def Execute(self, command):
|
||||
if IsWindows():
|
||||
args = '"%s"' % command
|
||||
else:
|
||||
args = command.split(" ")
|
||||
stdout = TempFile(prefix="test262-out-")
|
||||
stderr = TempFile(prefix="test262-err-")
|
||||
try:
|
||||
logging.info("exec: %s", str(args))
|
||||
process = subprocess.Popen(
|
||||
args,
|
||||
shell = IsWindows(),
|
||||
stdout = stdout.fd,
|
||||
stderr = stderr.fd
|
||||
)
|
||||
code = process.wait()
|
||||
out = stdout.Read()
|
||||
err = stderr.Read()
|
||||
finally:
|
||||
stdout.Dispose()
|
||||
stderr.Dispose()
|
||||
return (code, out, err)
|
||||
|
||||
def Run(self, command_template):
|
||||
tmp = TempFile(suffix=".js", prefix="test262-", text=True)
|
||||
try:
|
||||
result = self.RunTestIn(command_template, tmp)
|
||||
finally:
|
||||
tmp.Dispose()
|
||||
return result
|
||||
|
||||
def Print(self):
|
||||
print self.GetSource()
|
||||
|
||||
|
||||
class ProgressIndicator(object):
|
||||
|
||||
def __init__(self, count):
|
||||
self.count = count
|
||||
self.succeeded = 0
|
||||
self.failed = 0
|
||||
self.failed_tests = []
|
||||
|
||||
def HasRun(self, result):
|
||||
result.ReportOutcome(True)
|
||||
if result.HasUnexpectedOutcome():
|
||||
self.failed += 1
|
||||
self.failed_tests.append(result)
|
||||
else:
|
||||
self.succeeded += 1
|
||||
|
||||
|
||||
def MakePlural(n):
|
||||
if (n == 1):
|
||||
return (n, "")
|
||||
else:
|
||||
return (n, "s")
|
||||
|
||||
|
||||
class TestSuite(object):
|
||||
|
||||
def __init__(self, root, stric_mode):
|
||||
# self.test_root = path.join(root, 'test', 'suite', 'Sputnik', 'Conformance')
|
||||
# self.test_root = path.join(root, 'test', 'suite', 'other')
|
||||
self.test_root = path.join(root, 'test', 'suite', 'converted')
|
||||
self.lib_root = path.join(root, 'test', 'harness')
|
||||
self.strict_mode = stric_mode
|
||||
self.include_cache = { }
|
||||
|
||||
def Validate(self):
|
||||
if not path.exists(self.test_root):
|
||||
ReportError("No test repository found")
|
||||
if not path.exists(self.lib_root):
|
||||
ReportError("No test library found")
|
||||
|
||||
def IsHidden(self, path):
|
||||
return path.startswith('.') or path == 'CVS'
|
||||
|
||||
def IsTestCase(self, path):
|
||||
return path.endswith('.js')
|
||||
|
||||
def ShouldRun(self, rel_path, tests):
|
||||
if len(tests) == 0:
|
||||
return True
|
||||
for test in tests:
|
||||
if test in rel_path:
|
||||
return True
|
||||
return False
|
||||
|
||||
def GetTimeZoneInfoInclude(self):
|
||||
dst_attribs = GetDaylightSavingsAttribs()
|
||||
if not dst_attribs:
|
||||
return None
|
||||
lines = []
|
||||
for key in sorted(dst_attribs.keys()):
|
||||
lines.append('var $DST_%s = %s;' % (key, str(dst_attribs[key])))
|
||||
localtz = time.timezone / -3600
|
||||
lines.append('var $LocalTZ = %i;' % localtz)
|
||||
return "\n".join(lines)
|
||||
|
||||
def GetSpecialInclude(self, name):
|
||||
if name == "environment.js":
|
||||
return self.GetTimeZoneInfoInclude()
|
||||
else:
|
||||
return None
|
||||
|
||||
def GetInclude(self, name, strip_header=True):
|
||||
key = (name, strip_header)
|
||||
if not key in self.include_cache:
|
||||
value = self.GetSpecialInclude(name)
|
||||
if value:
|
||||
self.include_cache[key] = value
|
||||
else:
|
||||
static = path.join(self.lib_root, name)
|
||||
if path.exists(static):
|
||||
f = open(static)
|
||||
contents = f.read()
|
||||
if strip_header:
|
||||
contents = StripHeader(contents)
|
||||
self.include_cache[key] = contents + "\n"
|
||||
f.close()
|
||||
else:
|
||||
self.include_cache[key] = ""
|
||||
return self.include_cache[key]
|
||||
|
||||
def EnumerateTests(self, tests):
|
||||
logging.info("Listing tests in %s", self.test_root)
|
||||
cases = []
|
||||
for root, dirs, files in os.walk(self.test_root):
|
||||
for f in [x for x in dirs if self.IsHidden(x)]:
|
||||
dirs.remove(f)
|
||||
dirs.sort()
|
||||
for f in sorted(files):
|
||||
if self.IsTestCase(f):
|
||||
full_path = path.join(root, f)
|
||||
if full_path.startswith(self.test_root):
|
||||
rel_path = full_path[len(self.test_root)+1:]
|
||||
else:
|
||||
logging.warning("Unexpected path %s", full_path)
|
||||
rel_path = full_path
|
||||
if self.ShouldRun(rel_path, tests):
|
||||
basename = path.basename(full_path)[:-3]
|
||||
name = rel_path.split(path.sep)[:-1] + [basename]
|
||||
cases.append(TestCase(self, name, full_path, False))
|
||||
if self.strict_mode:
|
||||
cases.append(TestCase(self, name, full_path, True))
|
||||
logging.info("Done listing tests")
|
||||
return cases
|
||||
|
||||
def PrintSummary(self, progress):
|
||||
print
|
||||
print "=== Summary ==="
|
||||
count = progress.count
|
||||
succeeded = progress.succeeded
|
||||
failed = progress.failed
|
||||
print " - Ran %i test%s" % MakePlural(count)
|
||||
if progress.failed == 0:
|
||||
print " - All tests succeeded"
|
||||
else:
|
||||
percent = ((100.0 * succeeded) / count,)
|
||||
print " - Passed %i test%s (%.1f%%)" % (MakePlural(succeeded) + percent)
|
||||
percent = ((100.0 * failed) / count,)
|
||||
print " - Failed %i test%s (%.1f%%)" % (MakePlural(failed) + percent)
|
||||
positive = [c for c in progress.failed_tests if not c.case.IsNegative()]
|
||||
negative = [c for c in progress.failed_tests if c.case.IsNegative()]
|
||||
if len(positive) > 0:
|
||||
print
|
||||
print "Failed tests"
|
||||
for result in positive:
|
||||
print " %s" % result.case.GetName()
|
||||
if len(negative) > 0:
|
||||
print
|
||||
print "Expected to fail but passed ---"
|
||||
for result in negative:
|
||||
print " %s" % result.case.GetName()
|
||||
|
||||
def PrintFailureOutput(self, progress):
|
||||
for result in progress.failed_tests:
|
||||
print
|
||||
result.ReportOutcome(False)
|
||||
|
||||
def Run(self, command_template, tests, print_summary, full_summary):
|
||||
if not "{{path}}" in command_template:
|
||||
command_template += " {{path}}"
|
||||
cases = self.EnumerateTests(tests)
|
||||
if len(cases) == 0:
|
||||
ReportError("No tests to run")
|
||||
progress = ProgressIndicator(len(cases))
|
||||
for case in cases:
|
||||
result = case.Run(command_template)
|
||||
progress.HasRun(result)
|
||||
if print_summary:
|
||||
self.PrintSummary(progress)
|
||||
if full_summary:
|
||||
self.PrintFailureOutput(progress)
|
||||
else:
|
||||
print
|
||||
print "Use --full-summary to see output from failed tests"
|
||||
print
|
||||
|
||||
def Print(self, tests):
|
||||
cases = self.EnumerateTests(tests)
|
||||
if len(cases) > 0:
|
||||
cases[0].Print()
|
||||
|
||||
|
||||
def GetDaylightSavingsTimes():
|
||||
# Is the given floating-point time in DST?
|
||||
def IsDst(t):
|
||||
return time.localtime(t)[-1]
|
||||
# Binary search to find an interval between the two times no greater than
|
||||
# delta where DST switches, returning the midpoint.
|
||||
def FindBetween(start, end, delta):
|
||||
while end - start > delta:
|
||||
middle = (end + start) / 2
|
||||
if IsDst(middle) == IsDst(start):
|
||||
start = middle
|
||||
else:
|
||||
end = middle
|
||||
return (start + end) / 2
|
||||
now = time.time()
|
||||
one_month = (30 * 24 * 60 * 60)
|
||||
# First find a date with different daylight savings. To avoid corner cases
|
||||
# we try four months before and after today.
|
||||
after = now + 4 * one_month
|
||||
before = now - 4 * one_month
|
||||
if IsDst(now) == IsDst(before) and IsDst(now) == IsDst(after):
|
||||
logging.warning("Was unable to determine DST info.")
|
||||
return None
|
||||
# Determine when the change occurs between now and the date we just found
|
||||
# in a different DST.
|
||||
if IsDst(now) != IsDst(before):
|
||||
first = FindBetween(before, now, 1)
|
||||
else:
|
||||
first = FindBetween(now, after, 1)
|
||||
# Determine when the change occurs between three and nine months from the
|
||||
# first.
|
||||
second = FindBetween(first + 3 * one_month, first + 9 * one_month, 1)
|
||||
# Find out which switch is into and which if out of DST
|
||||
if IsDst(first - 1) and not IsDst(first + 1):
|
||||
start = second
|
||||
end = first
|
||||
else:
|
||||
start = first
|
||||
end = second
|
||||
return (start, end)
|
||||
|
||||
|
||||
def GetDaylightSavingsAttribs():
|
||||
times = GetDaylightSavingsTimes()
|
||||
if not times:
|
||||
return None
|
||||
(start, end) = times
|
||||
def DstMonth(t):
|
||||
return time.localtime(t)[1] - 1
|
||||
def DstHour(t):
|
||||
return time.localtime(t - 1)[3] + 1
|
||||
def DstSunday(t):
|
||||
if time.localtime(t)[2] > 15:
|
||||
return "'last'"
|
||||
else:
|
||||
return "'first'"
|
||||
def DstMinutes(t):
|
||||
return (time.localtime(t - 1)[4] + 1) % 60
|
||||
attribs = { }
|
||||
attribs['start_month'] = DstMonth(start)
|
||||
attribs['end_month'] = DstMonth(end)
|
||||
attribs['start_sunday'] = DstSunday(start)
|
||||
attribs['end_sunday'] = DstSunday(end)
|
||||
attribs['start_hour'] = DstHour(start)
|
||||
attribs['end_hour'] = DstHour(end)
|
||||
attribs['start_minutes'] = DstMinutes(start)
|
||||
attribs['end_minutes'] = DstMinutes(end)
|
||||
return attribs
|
||||
|
||||
|
||||
def Main():
|
||||
parser = BuildOptions()
|
||||
(options, args) = parser.parse_args()
|
||||
ValidateOptions(options)
|
||||
test_suite = TestSuite(options.tests, options.enable_strict_mode)
|
||||
test_suite.Validate()
|
||||
if options.cat:
|
||||
test_suite.Print(args)
|
||||
else:
|
||||
test_suite.Run(options.command, args,
|
||||
options.summary or options.full_summary,
|
||||
options.full_summary)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
try:
|
||||
Main()
|
||||
sys.exit(0)
|
||||
except Test262Error, e:
|
||||
print "Error: %s" % e.message
|
||||
sys.exit(1)
|
||||
Loading…
Reference in New Issue