mirror of https://github.com/tc39/test262.git
The Sputnik/IETC => test262 converter is no longer useful.
This commit is contained in:
David Fugate
parent
edd1628de5
commit
6d83f405b8
|
|
@ -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);
|
||||
|
|
@ -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);
|
||||
|
|
@ -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);
|
||||
|
|
@ -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);
|
||||
Loading…
Reference in New Issue