tyler.durden
/
test262
mirror of https://github.com/tc39/test262.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

The Sputnik/IETC => test262 converter is no longer useful.

This commit is contained in:
David Fugate 2011-11-04 11:16:13 -07:00
parent edd1628de5
commit 6d83f405b8
4 changed files with 0 additions and 1252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

171
tools/converter/browserPlatform.js
View File

@ -1,171 +0,0 @@
// Copyright 2011 by Google, Inc. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/**
* Each implementation of *Platform.js abstracts the underlying OS and JS
* engine peculiarities.
*
* <p>The implementation here is for running in many browsers, and so
* should assume the platform may be anything from ES3+Reality
* forward, including somewhat non-conformant implementations.
*/
(function (global) {
"use strict";
/////////////////// Development Switches /////////////////
var VERBOSE = true;
// Affects side effecting os operations,
// currently only platform.writeSpawn and platform.mkdir.
var DRY_RUN = false;
// When converting paths to path strings, should the pathstring be
// relative to the TEST262_ROOT, or should it be relative to the
// current working directory?
var ABSOLUTE_PATHSTR = false;
////////////////////////////////////////////////////////
global.t262 = global.t262 || {};
var platform = global.t262.platform = {};
var utils = global.t262.utils;
var forEach = utils.forEach;
var map = utils.map;
// Someday this will be https:
var ABS_ROOT_STR = 'http://test262.ecmascript.org/';
var TEST262_ROOT_STR = ABSOLUTE_PATHSTR ? ABS_ROOT : '';
var HARNESS_DIR = ['resources', 'scripts', 'global'];
platform.HARNESS_DIR = HARNESS_DIR;
var CONVERTER_DIR = ['resources', 'scripts', 'global'];
platform.CONVERTER_DIR = CONVERTER_DIR;
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;
////////////////// Needed for building and running tests //////////////
/**
*
*/
function validatePath(path) {
var pathStr = path.join('/');
forEach(path, function(segment) {
if (segment === '') {
throw new Error('A path cannot have empty segments: ' + pathStr);
}
if (segment === '/') {
throw new Error('Path insufficiently parsed: ' + pathStr);
}
if (segment === '..') {
throw new Error('Cannot use "..": ' + pathStr);
}
});
return path;
}
/**
* Converts a relPath to a relPathStr.
*
* A relPath is an array of filenames relative to some base onto
* which it will be concatenated before use.
*/
function toRelPathStr(relPath) {
validatePath(relPath);
return relPath.join('/');
}
platform.toRelPathStr = toRelPathStr;
/**
* Converts a path to a pathStr.
*
* A path is an array of filenames relative to TEST262_ROOT. A
* pathStr is a (possibly fully qualified string) for referring to
* that file on the current platform, according to the operations
* in this *Platform.js file.
*/
function toPathStr(path) {
validatePath(path);
return TEST262_ROOT_STR + path.join('/');
}
platform.toPathStr = toPathStr;
/**
* Returns the text found at path, with newlines normalized and
* any initial BOM (Unicode Byte Order Mark) removed.
*
* <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.
*/
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
* redirects its printed form to a chosen file (or resource).
*
* <p>For example, if !DRY_RUN, then<pre>
* writeSpawn([], 'print(+arguments[0] + +arguments[1]);', ['3', '5'])
* </pre>
* should return the string "8" if writeSpawn decides to spawn.
*
* @param scriptPaths An array of path arrays of JavaScript source
* files to be loaded into the spawned JS engine (in addition to
* the spawning platform file) if we are indeed spawning.
* @param opt_src A Program to be evaluated in an environment in
* which "arguments" is bound to the list of strings provided by
* opt_args. If spawned, the result is whatever the program writes
* to its stdout. On platforms (like SES) where this can be a
* safely confining evaluation, it should be. The implementation
* here is not safe.
* @param opt_args A list of strings to be bound to top-level
* 'arguments' both in opt_src and in the possibly spawed scripts.
* @param opt_targetPath A path array naming a file where the
* result of opt_src should be written. In the browser context, the
* result is PUT (or should that be POST), using XHR, to the target
* resource.
* @param opt_spawn_required If truthy, forces spawning.
* @returns If there is a target, then the null string. Otherwise,
* the string result of evaluating opt_src.
*/
function writeSpawn(scriptPaths,
opt_src,
opt_args,
opt_targetPath,
opt_spawn_required,
opt_forceNonStrict) {
"TBD"();
if (VERBOSE || DRY_RUN) { "TBD"(); }
if (DRY_RUN) { return ''; }
return "TBD";
}
platform.writeSpawn = writeSpawn;
////////////////// Only needed for running tests //////////////////////
})(this);

595
tools/converter/convert.js
View File

@ -1,595 +0,0 @@
// Copyright 2011 by Google, Inc. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
(function(global) {
"use strict";
var t262 = global.t262;
var platform = t262.platform;
var toRelPathStr = platform.toRelPathStr;
var toPathStr = platform.toPathStr;
var toRelPath = platform.toRelPath;
var toPath = platform.toPath;
var utils = t262.utils;
var forEach = utils.forEach;
var map = utils.map;
var filter = utils.filter;
var keys = utils.keys;
var trim = utils.trim;
var regExp = utils.regExp;
var CONTRIB_DIRS = [
['external', 'contributions', 'Google', 'sputnik_conformance_modified'],
['external', 'contributions', 'Microsoft', 'ietc_262modified']
];
var CONVERTED_DIR = ['test', 'suite'];
var OUT_DIR = ['website', 'resources', 'scripts', 'testcases2'];
var CONVERT_PATH = platform.CONVERTER_DIR.concat('convert.js');
/**
* Extra in the sense that they are not redundant with the source,
* but add information that should be present in the converted
* source. So not test/suite/SputnikGlobalScope.js, since that is
* actually derived from sources.
*/
var EXTRA_GLOBAL_SCOPE_TESTS = [
['external', 'contributions', 'Microsoft', 'ietc_262modified',
'IETCGlobalScope.js']
];
/**
* Try prepending this to a relPath if necessary to get an index
* into EXTRA_GLOBAL_SCOPE_TESTS.
*/
var EXTRANEOUS_PREFIXES = ['TestCases'];
/**
* Prepare for reading in the EXTRA_GLOBAL_SCOPE_TESTS, suppressing
* the "new Array()" that inappropriately still appears in
* IETCGlobalScope.js
*/
global.GlobalScopeTests = global.GlobalScopeTests || {};
global.EarlyErrorRePat = 'EarlyErrorRePat';
global.NotEarlyErrorString = 'NotEarlyError';
/////////////////////////////////////////////////////////////////
var headerPattern = /(?:(?:\/\/.*)?\s*\n)*/;
var captureCommentPattern = /\/\*\*?((?:\s|\S)*?)\*\/\s*\n/;
var anyPattern = /(?:\s|\S)*/;
var blanksPattern = /(?:\s|\n)*/;
var captureStrictPattern = /\s*('use strict'|"use strict");/;
// Should match anything
var testEnvelopePattern =
regExp('^(', headerPattern,
')(?:', captureCommentPattern,
')?(', anyPattern,
')$');
var registerPattern =
regExp('^(', anyPattern, '?)(',
/ES5Harness\.registerTest\s*\(\s*\{/, anyPattern,
/\}\s*\)/, ')',
/\s*;?(?:\s|\n)*$/);
// Matches a named function. Captures both the name and the body.
var captureFuncNameBodyPattern =
regExp(/^function\s+(\w*)\(\s*\)\s*\{/,
'(', anyPattern, ')',
/;?/, blanksPattern,
/\}$/);
var captureExprBodyPattern =
regExp(/^return\s+/,
'(', anyPattern, '?)',
/;$/);
var capturePredicatePattern =
regExp(/^if\s+\((.*?)\)\s*\{/, blanksPattern,
/return\s+true;?/, blanksPattern,
/\}$/);
/////////////////////////////////////////////////////////////////
/**
* Strip the left margin "*"s that are found in the body of a
* multiline doc-comment like this one.
*/
function stripStars(text) {
return trim(text.replace(/\s*\n\s*\*\s?/g, '\n'));
}
/**
* Parses the source of a test262 test case file into a JSON
* envelope record.
*
* <p>The input can be in old sputnik or ietestcenter style, or in
* the canonical test262 style. In all cases, we have an optional
* header, an optional "/*" comment possibly containing properties
* of the form<pre>
* @propName: propValue;
* </pre>which populate the test record. This is followed by the
* rest of the text, which is the test itself. In the case of an
* ietestcenter style test, this is followed by a call to
* <code>ES5Harness\.registerTest</code> to register a test record.
*/
function parseTestEnvelope(src, name) {
var envelope = { testRecord: {} };
var envelopeMatch = testEnvelopePattern.exec(src);
if (!envelopeMatch) {
// Can't happen?
throw new Error('unrecognized: ' + name);
}
envelope.header = trim(envelopeMatch[1]);
if (envelopeMatch[2]) {
var propTexts = envelopeMatch[2].split(/\s*\n\s*\*\s*@/);
// notice side effect by .shift()
envelope.commentary = stripStars(propTexts.shift()),
forEach(propTexts, function(propText) {
var propName = propText.match(/^\w+/)[0];
var propVal = propText.substring(propName.length);
// strip optional initial colon or final semicolon.
// The initial colon is only stripped if it comes immediately
// after the identifier with no intervening whitespace.
propVal = propVal.replace(/^:\s*/, '').replace(/;\s*$/, '');
propVal = stripStars(propVal);
if (propName in envelope.testRecord) {
throw new Error('duplicate: ' + propName);
}
envelope.testRecord[propName] = propVal;
});
}
envelope.rest = envelopeMatch[3]; // Do not trim
var strictMatch = captureStrictPattern.exec(envelope.rest);
if (strictMatch) {
envelope.testRecord.onlyStrict = '';
// Note: does not remove or alter the "use strict"; directive
// itself. We also make no use of the captured string so TODO:
// stop capturing it.
}
var registerMatch = registerPattern.exec(envelope.rest);
if (registerMatch) {
envelope.rest = trim(registerMatch[1]);
envelope.registerExpr = trim(registerMatch[2]);
} else if (envelope.rest.indexOf('ES5Harness.registerTest') >= 0) {
print(' \n--header---\n|' + envelope.header +
'|\n--rest-----\n|' + envelope.rest +
'|\n--harness--\n|' + envelope.registerExpr +
'|\n-----------\n');
throw new Error('Malformed harness? ' + name);
}
return envelope;
}
/**
* Given a function that indicates success by returning a truthy
* value, return the source for a Program that, when evaluated in
* the environment the function assumes, will behave the same as
* calling that function in that environment and asserting the
* truthiness of the result.
*
* <p>Programs do not conveniently return any value, even their
* completion value, so Programs in canonical test262 style instead
* indicate success simply by completing normally, i.e., without
* throwing anything. The conversion assumes a one argument
* <code>runTestCase</code> function which calls it function
* argument and throws an indication of test failure iff that
* function returns a falsy argument.
*
* <p>Unless it specifies otherwise, the Program source may be
* executed strict and/or non-strict, and it may be exeuted within
* the try block of a try/catch or try/catch finally, i.e., as a
* Block rather than as a Program.
*/
function functionToProgramSrc(func) {
var funcSrc = '' + func;
var cfnbMatch = captureFuncNameBodyPattern.exec(funcSrc);
if (!cfnbMatch) {
throw new Error('Could not recognize: "' + funcSrc + '"');
}
var name = trim(cfnbMatch[1]);
var body = trim(cfnbMatch[2]);
// Uncomment to look for special cases
//
// var cebMatch = captureExprBodyPattern.exec(body);
// if (cebMatch) {
// return 'assertTruthy(' + trim(cebMatch[1]) + ');';
// }
//
// var cpMatch = capturePredicatePattern.exec(body);
// if (cpMatch) {
// return 'assertTruthy(' + trim(cpMatch[1]) + ');';
// }
// General case
return funcSrc + '\n' +
'runTestCase(' + name + ');';
}
/**
* If record[toName] is absent or empty and record[fromName] is
* present, whether empty or not, then set record[toName] to the
* current value of record[fromName] and delete record[fromName]
*/
function transferProp(record, fromName, toName) {
// Note that record[toName] is falsy whether toName is absent or
// empty
if (!record[toName] && fromName in record) {
record[toName] = record[fromName];
delete record[fromName];
}
}
/**
* Given an ietestcenter style test, this <b>evaluates</b> the
* registration expression in order to gather the test record.
*/
function gatherOne(envelope, name) {
var testRecord = envelope.testRecord;
var testRecords = [];
// Evaluating!!!!
platform.evalExprIn(envelope.registerExpr,
{
ES5Harness: {
registerTest: function(testRecord) {
testRecords.push(testRecord);
}
}
},
'forceNonStrict');
if (testRecords.length !== 1) {
// We may lift this restriction in order to support test
// generators.
throw new Error('not singleton: ' + name);
}
var gatheredTestRecord = testRecords[0];
forEach(keys(gatheredTestRecord), function(propName) {
if (propName in testRecord &&
testRecord[propName] !== gatheredTestRecord[propName]) {
throw new Error('Conflicting "' + propName + '" in ' + name);
}
testRecord[propName] = gatheredTestRecord[propName];
});
if (typeof testRecord.test === 'function') {
testRecord.test = envelope.rest + '\n' +
functionToProgramSrc(testRecord.test);
}
if ('precondition' in testRecord) {
// Only ietestcenter tests currently have preconditions, and they
// plan to drop them. So canonical test262 style omits
// them.
delete testRecord.precondition;
}
return testRecord;
}
/**
* Normalizes the properties of testRecord to be the canonical
* test262 style properties, that will be assumed by the new test
* runners.
*/
function normalizeProps(testRecord) {
if (!('onlyStrict' in testRecord) && testRecord.strict === 1) {
testRecord.onlyStrict = '';
}
if (testRecord.strict === 1) {
delete testRecord.strict;
}
if ('strict_mode_negative' in testRecord) {
if (!('onlyStrict' in testRecord)) {
testRecord.onlyStrict = '';
}
transferProp(testRecord, 'strict_mode_negative', 'negative');
}
transferProp(testRecord, 'strict_only', 'onlyStrict');
transferProp(testRecord, 'non_strict_only', 'noStrict');
transferProp(testRecord, 'errortype', 'negative');
transferProp(testRecord, 'assertion', 'description');
transferProp(testRecord, 'assertion', 'commentary');
}
t262.normalizeProps = normalizeProps;
/**
* If relPath is represented in the EXTRA_GLOBAL_SCOPE_TESTS,
* retrieve the corresponding record. Otherwise, return undefined.
*/
function getGlobalScopeRecord(relPath) {
var key = toRelPathStr(relPath);
var val = global.GlobalScopeTests[key];
if (!val) {
key = toRelPathStr(EXTRANEOUS_PREFIXES.concat(relPath));
val = global.GlobalScopeTests[key];
}
return val;
}
t262.getGlobalScopeRecord = getGlobalScopeRecord;
/**
* Parses the source of a test262 test case file into a normalized
* JSON test record.
*/
function parseTestRecord(inBase, relPath, name) {
var nextRelPath = relPath.concat([name]);
var nextPath = inBase.concat(nextRelPath);
var src = platform.getText(nextPath);
var testRecord;
if (!src) {
throw new Error('no src: ' + toPathStr(nextPath));
}
var envelope = parseTestEnvelope(src, name);
if (envelope.registerExpr) {
testRecord = gatherOne(envelope, name);
} else {
testRecord = envelope.testRecord;
if (!testRecord.test) {
testRecord.test = envelope.rest;
}
}
var globalScopeRecord = getGlobalScopeRecord(nextRelPath);
if (globalScopeRecord) {
forEach(keys(globalScopeRecord), function(key) {
if (!(key in testRecord) && key !== 'precondition') {
testRecord[key] = globalScopeRecord[key];
}
});
}
delete testRecord.id;
delete testRecord.name;
delete testRecord.section;
testRecord.path = toRelPathStr(nextRelPath);
testRecord.header = envelope.header;
testRecord.commentary = envelope.commentary;
normalizeProps(testRecord);
return testRecord;
}
t262.parseTestRecord = parseTestRecord;
// If we see any properties other than these after normalization,
// we signal an error.
var KNOWN_PROPS = ['path', 'description',
'noStrict', 'onlyStrict', 'negative',
// Not yet supported ones that should not be
// accepted until they are supported are
// commented aout below. Not supported ones that
// can safely be present and ignored are enabled
// below.
// 'generator', 'verbatim',
'noHelpers', 'bestPractice'
];
/**
* Turns the (assumed) normalized test record into its string form
* in canonical test262 style.
*
* NOTE: This is currently destructive of testRecord. Easy to fix
* if it becomes a problem.
*/
function formatTestRecord(testRecord) {
var test = testRecord.test;
delete testRecord.test;
function addProp(pname) {
if (pname in testRecord) {
result += ' * @' + pname;
if (testRecord[pname]) {
result += ' ' + testRecord[pname].replace(/\n/g, '\n * ');
}
result += '\n';
delete testRecord[pname];
}
}
var result = testRecord.header + '\n\n';
delete testRecord.header;
result += '/**\n';
if (testRecord.commentary) {
result += ' * ' + testRecord.commentary.replace(/\n/g, '\n * ') +
'\n *\n';
}
delete testRecord.commentary;
forEach(KNOWN_PROPS, addProp);
var remaining = keys(testRecord);
if (remaining.length >= 1) {
// If we wanted to preserve unrecognized properties, we'd
// uncomment the following and comment out the next
//forEach(remaining, addProp);
throw new Error('unrecognized: ' + remaining);
}
result += ' */\n\n' + test;
return result;
}
t262.formatTestRecord = formatTestRecord;
/**
* 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);
var relPath = platform.toRelPath(relPathStr);
var name = relPath.pop();
var testRecord = parseTestRecord(inBase, relPath, name);
var result = formatTestRecord(testRecord);
return result;
}
t262.convertTest = convertTest;
var writeSpawnFailures = [];
/**
* Convert all the testcases found at inBase+relDir to test cases
* in canonical test262 style, to be stored at corresponding
* positions in outBase+relPath.
*/
function convertAll(inBase, outBase, relPath) {
var inPath = inBase.concat(relPath);
var outPath = outBase.concat(relPath);
platform.mkdir(outPath);
forEach(platform.ls(inPath), function(name) {
var nextRelPath = relPath.concat([name]);
if (platform.isDirectory(inBase.concat(nextRelPath))) {
convertAll(inBase, outBase, nextRelPath);
} else if (/\.js$/.test(name) && !(/IETCGlobalScope\.js$/.test(name))) {
var outFilePath = outPath.concat([name]);
try {
platform.writeSpawn(
[CONVERT_PATH].concat(EXTRA_GLOBAL_SCOPE_TESTS),
't262.show(t262.convertTest("' + toPathStr(inBase) +
'", "' + toRelPathStr(nextRelPath) + '"));',
void 0,
outFilePath);
} catch (err) {
writeSpawnFailures.push({
error: err,
relPath: relPath
});
}
}
});
}
t262.convertAll = convertAll;
/**
* Do all the conversions (from sputnik style, ietestcenter style,
* or other to canonical test262 style) matching relPath.
*/
function convert(opt_relPathStr) {
var relPath = opt_relPathStr ? toRelPath(opt_relPathStr) : [];
writeSpawnFailures = [];
forEach(CONTRIB_DIRS, function(srcDir) {
convertAll(srcDir, CONVERTED_DIR, relPath);
});
if (writeSpawnFailures.length >= 1) {
print('********* failures **********');
forEach(writeSpawnFailures, function(failure) {
print(failure.error + ': ' + toRelPathStr(failure.relPath));
});
throw writeSpawnFailures[0].error;
}
}
t262.convert = convert;
/**
* Reads all the test case records for the section corresponding to
* the directory at pathStr, and return a JSON record for a test
* case section, as would be uploaded to a browser-based test
* runner.
*/
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(inBase, relPath, name);
delete testRecord.header;
delete testRecord.commentary;
return testRecord;
});
testRecords = filter(testRecords, function(testRecord) {
return testRecord !== null;
});
return {
testCollection: {
name: path[path.length -1],
numTests: testRecords.length,
tests: testRecords
}
};
}
t262.buildSection = buildSection;
/**
* Use the test cases at inBase+relPath to build the test
* collection portion of the website, at outBase.
*/
function buildAll(inBase, outBase, relPath) {
var inPath = inBase.concat(relPath);
var hasJS = false;
forEach(platform.ls(inPath), function(name) {
var nextRelPath = relPath.concat([name]);
if (platform.isDirectory(inBase.concat(nextRelPath))) {
buildAll(inBase, outBase, nextRelPath);
} else if (/\.js$/.test(name)) {
hasJS = true;
}
});
if (hasJS) {
var name = relPath[relPath.length -1] + '.json';
var outFilePath = outBase.concat([name]);
try {
platform.writeSpawn(
[CONVERT_PATH].concat(EXTRA_GLOBAL_SCOPE_TESTS),
't262.showJSON(t262.buildSection("' + toPathStr(inBase) +
'", "' + toRelPathStr(nextRelPath) + '"));',
void 0,
outFilePath);
} catch (err) {
writeSpawnFailures.push({
error: err,
path: relPath
});
}
}
}
t262.buildAll = buildAll;
/**
* Build those test case files for the website corresponding to the
* test cases matching relPath.
*
* <p>Right now it's building from the pre-converted test
* files. Once we switch over to converted as the maintained
* sources, we should change this.
*/
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;
})(this);

118
tools/converter/utils.js
View File

@ -1,118 +0,0 @@
// Copyright 2011 by Google, Inc. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/**
* General conveniences, including some functionality available in ES5
* but not ES3.
*
* <p>This file must be able to run in many browsers, and so should
* assume the platform may be anything from ES3+Reality forward,
* including somewhat non-conformant implementations. It must also be
* able to run in a non-browser environment, such as from the command
* line.
*
* <p>The conveniences that are analogs of similar ES5 features are
* not full emulations, but only emulations of the portion of their
* semantics we need.
*/
(function(global) {
"use strict";
global.t262 = global.t262 || {};
var utils = global.t262.utils = global.t262.utils || {};
////////////////////////////////////////////////////////
/**
* Like ES5 call.bind([].forEach)(list, func), but supporting fewer
* optional arguments.
*/
function forEach(list, func) {
for (var i = 0, len = list.length; i < len; i++) {
func(list[i], i);
}
}
utils.forEach = forEach;
/**
* Like ES5 call.bind([].map)(list, func), but supporting fewer
* optional arguments.
*/
function map(list, func) {
var result = [];
for (var i = 0, len = list.length; i < len; i++) {
result.push(func(list[i], i));
}
return result;
}
utils.map = map;
/**
* Like ES5 call.bind([].filter)(list, pred), but supporting fewer
* optional arguments.
*/
function filter(list, pred) {
var result = [];
for (var i = 0, len = list.length; i < len; i++) {
if (pred(list[i], i)) { result.push(list[i]); }
}
return result;
}
utils.filter = filter;
/**
* Like ES5 Object.keys(obj).
*/
function keys(obj) {
var result = [];
var hop = {}.hasOwnProperty;
for (var k in obj) {
if (hop.call(obj, k)) { result.push(k); }
}
return result;
}
utils.keys = keys;
/**
* Like ES5 call.bind(''.trim)(string).
*/
function trim(str) {
return str.replace(/^\s*/, '').replace(/\s*$/, '');
}
utils.trim = trim;
/**
* 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.
*/
function regExp(var_args) {
var args = [].slice.call(arguments, 0);
var reSrc = map(args, 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);
}
utils.regExp = regExp;
})(this);

368
tools/converter/v8PosixPlatform.js
View File

@ -1,368 +0,0 @@
// Copyright 2011 by Google, Inc. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/**
* Each implementation of *Platform.js abstracts the underlying OS and JS
* engine peculiarities.
*
* <p>The implementation here is specific to the v8 shell running on a
* Posix platform. Therefore, it may legitimately use ES5 features,
* although it generally avoids them for consistency with the rest of
* test262.
*/
(function (global) {
"use strict";
/////////////////// Development Switches /////////////////
var VERBOSE = true;
// Affects side effecting os operations,
// currently only platform.writeSpawn and platform.mkdir.
var DRY_RUN = false;
// When converting paths to path strings, should the pathstring be
// relative to the TEST262_ROOT, or should it be relative to the
// current working directory?
var ABSOLUTE_PATHSTR = false;
////////////////////////////////////////////////////////
global.t262 = global.t262 || {};
var platform = global.t262.platform = {};
var utils = global.t262.utils;
var forEach = utils.forEach;
var map = utils.map;
var keys = utils.keys;
var trim = utils.trim;
try {
read('tools/converter/v8PosixPlatform.js');
} catch (err) {
throw new Error('Must run in a test262 source root');
}
var ABS_ROOT = trim(os.system('pwd', ['-P'])).split('/');
var TEST262_ROOT = ABSOLUTE_PATHSTR ? ABS_ROOT : [];
var TEST262_ROOT_STR = TEST262_ROOT.join('/');
var HARNESS_DIR = ['test', 'harness'];
platform.HARNESS_DIR = HARNESS_DIR;
var CONVERTER_DIR = ['tools', 'converter'];
platform.CONVERTER_DIR = CONVERTER_DIR;
var PLATFORM_PATHS = [
CONVERTER_DIR.concat('utils.js'),
CONVERTER_DIR.concat('v8PosixPlatform.js')
];
////////////////// Needed for building and running test //////////////
/**
*
*/
function validatePath(path) {
var pathStr = path.join('/');
forEach(path, function(segment) {
if (segment === '') {
throw new Error('A path cannot have empty segments: ' + pathStr);
}
if (segment === '/') {
throw new Error('Path insufficiently parsed: ' + pathStr);
}
if (segment === '..') {
throw new Error('Cannot use "..": ' + pathStr);
}
});
return path;
}
/**
* Converts a relPath to a relPathStr.
*
* A relPath is an array of filenames relative to some base onto
* which it will be concatenated before use.
*/
function toRelPathStr(relPath) {
validatePath(relPath);
return relPath.join('/');
}
platform.toRelPathStr = toRelPathStr;
/**
* Converts a path to a pathStr.
*
* A path is an array of filenames relative to TEST262_ROOT. A
* pathStr is a (possibly fully qualified string) for referring to
* that file on the current platform, according to the operations
* in this *Platform.js file.
*/
function toPathStr(path) {
validatePath(path);
return TEST262_ROOT.concat(path).join('/');
}
platform.toPathStr = toPathStr;
/**
* Returns the text found at path, with newlines normalized and
* any initial BOM (Unicode Byte Order Mark) removed.
*/
function getText(path) {
var text = read(toPathStr(path));
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;
/**
*
*/
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).
*
* <p>For example, if !DRY_RUN, then<pre>
* platform.writeSpawn([],
* 't262.show(+arguments[0] + +arguments[1]);',
* ['3', '5'])
* </pre>
* should emit string "8" to stdout.
*
* <p>To spawn a platform distinct from the present one -- for
* example, as outer v8-based driver can drive a rhino-based child
* -- create a distinct object representing that other platform and
* invoke its writeSpawn method.
*
* @param scriptPaths An array of path arrays of JavaScript source
* files to be loaded into the spawned JS engine, after
* PLATFORM_PATHS, if we are indeed spawning.
* @param opt_src A Program to be evaluated in an environment in
* which "arguments" is bound to the list of strings provided by
* opt_args. If spawned, the result is whatever the program writes
* to its stdout. On platforms (like SES) where this can be a
* safely confining evaluation, it should be. The implementation
* here is not safe.
* @param opt_args A list of strings to be bound to top-level
* 'arguments' both in opt_src and in the possibly spawed scripts.
* @param opt_targetPath A path array naming a file where the
* result of opt_src should be written. On v8 currently, if this is
* provided, then writeSpawn will spawn, since we have no other way
* to implement this functionality. In the browser context, the
* result is PUT (or should that be POST), using XHR, to the target
* resource.
* @param opt_spawn_required If truthy, forces spawning.
* @returns If there is a target, then the null string. Otherwise,
* the string result of evaluating opt_src.
*/
function writeSpawn(scriptPaths,
opt_src,
opt_args,
opt_targetPath,
opt_spawn_required,
opt_forceNonStrict) {
if (typeof opt_src === 'string' &&
!opt_targetPath &&
!opt_spawn_required) {
var str = '(function(/*var_args*/) { ';
if (opt_forceNonStrict !== 'forceNonStrict') {
str += '"use strict"; ';
}
str += opt_src + '\n})';
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 (typeof opt_src === 'string') {
cmd += ' -e ' + bashQuote(opt_src);
}
if (opt_args) {
cmd += ' -- ' + map(opt_args, bashQuote).join(' ');
}
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 {
try {
result = sys('bash', ['-c', cmd]);
} catch (err) {
// The error we catch is almost certainly less interesting
// than the one unfortunately written to the target file.
var message = 'failed: ' + cmd + '\n---\n' + read(tempPathStr);
throw new Error(message);
}
if (opt_targetPath) {
sys('cp', [tempPathStr, toPathStr(opt_targetPath)]);
}
return result;
} finally {
sys('rm', ['-f', tempPathStr]);
}
}
platform.writeSpawn = writeSpawn;
////////////////// Only needed for building tests /////////////////////
/**
* Calls a non-strict indirect eval function on exprSrc.
*
* <p>On platforms (like SES) where this can be a safely confining
* evaluation, it should be. The implementation here is not safe.
*/
function evalExprIn(exprSrc, env, opt_forceNonStrict) {
var varNames = keys(env);
var str = '(function(' + varNames.join(',') + ') {';
if (opt_forceNonStrict !== 'forceNonStrict') {
str += '"use strict";';
}
str += ' return (' + exprSrc + '); })';
var vals = map(varNames, function(varName) { return env[varName]; });
return (1,eval)(str).apply(void 0, vals);
}
platform.evalExprIn = evalExprIn;
/**
* Converts a relPathStr to a relPath.
*
* <p>See toRelPathStr.
*/
function toRelPath(relPathStr) {
return validatePath(relPathStr.split('/'));
}
platform.toRelPath = toRelPath;
/**
* Converts a pathStr to a path.
*
* <p>See toPathStr.
*/
function toPath(pathStr) {
if (pathStr[0] === '/') {
if (pathStr.indexOf(TEST262_ROOT_STR + '/') !== 0) {
throw new Error('"' + pathStr + '" must start with "' +
TEST262_ROOT_STR + '/"');
}
pathStr = pathStr.substring(TEST262_ROOT_STR.length + 1);
}
return validatePath(pathStr.split('/'));
}
platform.toPath = toPath;
/**
* Does path name a directory?
*/
function isDirectory(path) {
try {
os.system('test', ['-d', toPathStr(path)]);
return true;
} catch (x) {
return false;
}
}
platform.isDirectory = isDirectory;
/**
* A list of the filenames found in path, which must name a
* directory.
*/
function ls(path) {
var pathStr = toPathStr(path);
if (!isDirectory(path)) { return []; }
var lines;
try {
lines = trim(os.system('ls', [pathStr]));
} catch (err) {
throw err;
}
if (lines === '') { return []; }
return lines.split('\n');
}
platform.ls = ls;
/**
* If the directory does not yet exist, create it.
*/
function mkdir(path) {
var pathStr = toPathStr(path);
if (DRY_RUN) {
print('mkdir ' + pathStr);
return;
}
try {
os.mkdirp(pathStr);
} catch (err) {
print('***could not mkdir: ' + pathStr);
throw err;
}
}
platform.mkdir = mkdir;
/**
* Emits the text itself followed by a newline.
*
* <p>On the v8 shell, this is identical to "print".
*/
var show = global.t262.show = print;
/**
* Emits the jsonRecord serialized as JSON, either compactly or
* readably according to VERBOSE.
*/
function showJSON(jsonRecord) {
if (VERBOSE) {
print(JSON.stringify(jsonRecord, void 0, ' '));
} else {
print(JSON.stringify(jsonRecord));
}
}
global.t262.showJSON = platform.showJSON = showJSON;
////////////////// 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);