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. - * - *
Not platform dependent, so does not really belong in this - * file. - * - *
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. + *
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); diff --git a/tools/converter/convert.js b/tools/converter/convert.js index 6c99aac4a7..902551e72d 100644 --- a/tools/converter/convert.js +++ b/tools/converter/convert.js @@ -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 @@ -314,7 +314,7 @@ * in canonical test262 style. * * NOTE: This is currently destructive of testRecord. Easy to fix - *if it becomes a problem. + * if it becomes a problem. */ function formatTestRecord(testRecord) { var test = testRecord.test; @@ -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); +// 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; diff --git a/tools/converter/v8PosixPlatform.js b/tools/converter/v8PosixPlatform.js index f2d9b64510..0864fd7322 100644 --- a/tools/converter/v8PosixPlatform.js +++ b/tools/converter/v8PosixPlatform.js @@ -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]); - } catch (err) { - if (opt_targetPath) { + 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' + 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); diff --git a/tools/test262.py b/tools/test262.py new file mode 100644 index 0000000000..8d50c68993 --- /dev/null +++ b/tools/test262.py @@ -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)