From 9b3649f67bf252bf12cd37b37f796f75c38a6e8c Mon Sep 17 00:00:00 2001 From: "bclary%bclary.com" Date: Mon, 10 Jul 2006 00:11:25 +0000 Subject: [PATCH] JavaScript Test Library - regression test for bug 336376, by Jeff Walden --- js/tests/js1_7/lexical/browser.js | 0 js/tests/js1_7/lexical/regress-336376-01.js | 424 ++++++++++++++++++++ js/tests/js1_7/lexical/shell.js | 0 3 files changed, 424 insertions(+) create mode 100755 js/tests/js1_7/lexical/browser.js create mode 100755 js/tests/js1_7/lexical/regress-336376-01.js create mode 100755 js/tests/js1_7/lexical/shell.js diff --git a/js/tests/js1_7/lexical/browser.js b/js/tests/js1_7/lexical/browser.js new file mode 100755 index 00000000000..e69de29bb2d diff --git a/js/tests/js1_7/lexical/regress-336376-01.js b/js/tests/js1_7/lexical/regress-336376-01.js new file mode 100755 index 00000000000..ed339a7c369 --- /dev/null +++ b/js/tests/js1_7/lexical/regress-336376-01.js @@ -0,0 +1,424 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is JavaScript Engine testing utilities. + * + * The Initial Developer of the Original Code is + * Jeff Walden . + * Portions created by the Initial Developer are Copyright (C) 2006 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ +//----------------------------------------------------------------------------- +var bug = "336376"; +var summary = "Tests reserved words in contexts in which they are not reserved"; +var actual, expect; + +printBugNumber(bug); +printStatus(summary); + +/************** + * TEST SETUP * + **************/ + +// +// New tests go in Tester.prototype._tests. A test is called with a single +// argument, the keyword to test in the syntax tested by that test. Tests +// should not return anything, and they should signal failure by throwing an +// explanatory exception and success by not throwing one. +// +// If you define a new test, make sure to name it using an informative string +// for ease of use if any keywords ever manually define the array of tests they +// should pass, and add it as a string to ALL_TESTS. +// + +// all tests +const ALL_TESTS = + [ + "CONTEXT_OBJECT_LITERAL_PROPERTY", + "CONTEXT_OBJECT_PROPERTY_DOT_REFERENCE", + "CONTEXT_OBJECT_PROPERTY_DOT_REFERENCE_IS_FUNCTION", + "CONTEXT_OBJECT_PROPERTY_DOT_GET", + "CONTEXT_OBJECT_PROPERTY_DOT_SET", + "CONTEXT_XML_DESCENDANTS", + "CONTEXT_XML_NAMESPACE_QUALIFIED_ELEMENT", + "CONTEXT_XML_NAMESPACE_QUALIFIED_ATTR", + ]; + +function r(keyword, tests) +{ + /** + * @param keyword + * the keyword as a string + * @param tests + * array of test numbers against it, or leave undefined to run all tests + * against it + */ + function Reserved(keyword, tests) + { + this.keyword = keyword; + if (tests) + this.tests = tests; + else + this.tests = ALL_TESTS; + } + Reserved.prototype = + { + toString: + function() + { + return "'" + this.keyword + "' being run against tests " + + this.tests; + } + }; + return new Reserved(keyword, tests); +} + +// ECMA-262, 3rd. ed. keywords -- see 7.5.2 +const ECMA_262_3_KEYWORD = + [ + r("break"), + r("case"), + r("catch"), + r("continue"), + r("default"), + r("delete"), + r("do"), + r("else"), + r("finally"), + r("for"), + r("function"), + r("if"), + r("in"), + r("instanceof"), + r("new"), + r("return"), + r("switch"), + r("this"), + r("throw"), + r("try"), + r("typeof"), + r("var"), + r("void"), + r("while"), + r("with"), + ]; + +// ECMA-262, 3rd. ed. future reserved keywords -- see 7.5.3 +const ECMA_262_3_FUTURERESERVEDKEYWORD = + [ + r("abstract"), + r("boolean"), + r("byte"), + r("char"), + r("class"), + r("const"), + r("debugger"), + r("double"), + r("enum"), + r("export"), + r("extends"), + r("final"), + r("float"), + r("goto"), + r("implements"), + r("import"), + r("int"), + r("interface"), + r("long"), + r("native"), + r("package"), + r("private"), + r("protected"), + r("public"), + r("short"), + r("static"), + r("super"), + r("synchronized"), + r("throws"), + r("transient"), + r("volatile"), + ]; + +// like reserved words, but not quite reserved words +const PSEUDO_RESERVED = + [ + r("true"), + r("false"), + r("null"), + r("each"), // |for each| + ]; + +// new-in-ES4 reserved words -- fill this as each is implemented +const ECMA_262_4_RESERVED_WORDS = + [ + r("let") + ]; + + + +/** + * @param keyword + * string containing the tested keyword + * @param test + * the number of the failing test + * @param error + * the exception thrown when running the test + */ +function Failure(keyword, test, error) +{ + this.keyword = keyword; + this.test = test; + this.error = error; +} +Failure.prototype = + { + toString: + function() + { + return "*** FAILURE on '" + this.keyword + "'!\n" + + "* test: " + this.test + "\n" + + "* error: " + this.error + "\n"; + } + }; + +function Tester() +{ + this._failedTests = []; +} +Tester.prototype = + { + testReservedWords: + function(reservedArray) + { + var rv; + for (var i = 0, sz = reservedArray.length; i < sz; i++) + { + var res = reservedArray[i]; + if (!res) + continue; + + var tests = res.tests; + for (var j = 0, sz2 = tests.length; j < sz2; j++) + { + var test = tests[j]; + if (!test) + continue; + + try + { + this._tests[test](res.keyword); + } + catch (e) + { + this._failedTests.push(new Failure(res.keyword, test, e)); + } + } + } + }, + flushErrors: + function () + { + if (this._failedTests.length > 0) { + var except = "*************************\n" + + "* FAILURES ENCOUNTERED! *\n" + + "*************************\n"; + for (var i = 0, sz = this._failedTests.length; i < sz; i++) + except += this._failedTests[i]; + throw except; + } + }, + _tests: + { + CONTEXT_OBJECT_LITERAL_PROPERTY: + function(keyword) + { + try + { + eval("var o = { " + keyword + ": 17 };\n" + + "if (o['" + keyword + "'] != 17)\n" + + "throw \"o['" + keyword + "'] == 17\";"); + } + catch (e) + { + throw e; + } + }, + CONTEXT_OBJECT_PROPERTY_DOT_REFERENCE: + function(keyword) + { + try + { + eval("var o = { \"" + keyword + "\": 17, baz: null };\n" + + "if (o." + keyword + " != 17)\n" + + "throw \"o." + keyword + " == 17\";"); + } + catch (e) + { + throw e; + } + }, + CONTEXT_OBJECT_PROPERTY_DOT_REFERENCE_IS_FUNCTION: + function(keyword) + { + try + { + eval("var o = { '" + keyword + "': function() { return 17; }, baz: null };\n" + + "if (o." + keyword + "() != 17)\n" + + "throw \"o." + keyword + " == 17\";"); + } + catch (e) + { + throw e; + } + }, + CONTEXT_OBJECT_PROPERTY_DOT_GET: + function(keyword) + { + try + { + var o = {}; + eval("o['" + keyword + "'] = 17;\n" + + "if (o." + keyword + " != 17)\n" + + "throw \"'o." + keyword + " != 17' failed!\";"); + } + catch (e) + { + throw e; + } + }, + CONTEXT_OBJECT_PROPERTY_DOT_SET: + function(keyword) + { + try + { + var o = {}; + eval("o." + keyword + " = 17;\n" + + "if (o['" + keyword + "'] != 17)\n" + + "throw \"'o." + keyword + " = 17' failed!\";"); + } + catch (e) + { + throw e; + } + }, + CONTEXT_XML_DESCENDANTS: + function(keyword) + { + try + { + eval("var x = <" + keyword + " id='1'/><" + keyword + " f='g'/>;\n" + + "if (x.." + keyword + ".length() != 2 ||\n" + + " x.." + keyword + " != \n" + + " <><" + keyword + " id='1'/><" + keyword + " f='g'/>)\n" + + "throw \"'x.." + keyword + ".length()' failed!\";"); + } + catch (e) + { + throw e; + } + }, + CONTEXT_XML_NAMESPACE_QUALIFIED_ELEMENT: + function(keyword) + { + try + { + var bar = new Namespace("http://localhost/"); + eval("var x = \n\ + \n\ + \n\ + \n\ + \n\ + \n\ + \n\ + \n\ + \n\ + \n\ + ;\n\ + if (x.quiz.bar::" + keyword + " != \n\ + \n\ + \n\ + ||\n\ + x..bar::" + keyword + " != \n\ + <>\n\ + \n\ + \n\ + )\n\ + throw 'reserved names in XML namespace-qualified stuff are broken!';"); + } + catch (e) + { + throw e; + } + }, + CONTEXT_XML_NAMESPACE_QUALIFIED_ATTR: + function(keyword) + { + try + { + var bar = new Namespace("http://localhost/"); + eval("var x = \ + \ + ;\n\ + if (x.fin.@bar::" + keyword + " != 5)\n\ + throw 'namespaced attributes which are keywords are broken!';"); + } + catch (e) + { + throw e; + } + } + } + }; + + +/*************** + * BEGIN TESTS * + ***************/ + +var failed = false; + +try +{ + var tester = new Tester(); + tester.testReservedWords(ECMA_262_3_KEYWORD); + tester.testReservedWords(ECMA_262_3_FUTURERESERVEDKEYWORD); + tester.testReservedWords(PSEUDO_RESERVED); + tester.testReservedWords(ECMA_262_4_RESERVED_WORDS); + tester.flushErrors(); +} +catch (e) +{ + failed = e; +} + +expect = false; +actual = failed; + +reportCompare(expect, actual, summary); diff --git a/js/tests/js1_7/lexical/shell.js b/js/tests/js1_7/lexical/shell.js new file mode 100755 index 00000000000..e69de29bb2d