mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
442 lines
11 KiB
JavaScript
442 lines
11 KiB
JavaScript
/* -*- 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 <jwalden+code@mit.edu>.
|
|
* 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 gTestfile = 'regress-336376-01.js';
|
|
//-----------------------------------------------------------------------------
|
|
var BUGNUMBER = "336376";
|
|
var summary = "Tests reserved words in contexts in which they are not reserved";
|
|
var actual, expect;
|
|
|
|
printBugNumber(BUGNUMBER);
|
|
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",
|
|
"CONTEXT_XML_ATTRIBUTE_SELECTOR",
|
|
];
|
|
|
|
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 = <foo><biz><" + keyword + " id='1'/></biz><" + keyword + " f='g'/></foo>;\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 = <foo xmlns:bar='http://localhost/'>\n\
|
|
<bar>\n\
|
|
<baz/>\n\
|
|
</bar>\n\
|
|
<bar:" + keyword + " id='17'/>\n\
|
|
<quiz>\n\
|
|
<bar:" + keyword + ">\n\
|
|
<bunk/>\n\
|
|
</bar:" + keyword + ">\n\
|
|
</quiz>\n\
|
|
</foo>;\n\
|
|
if (x.quiz.bar::" + keyword + " != \n\
|
|
<bar:" + keyword + " xmlns:bar='http://localhost/'>\n\
|
|
<bunk/>\n\
|
|
</bar:" + keyword + "> ||\n\
|
|
x..bar::" + keyword + " != \n\
|
|
<><bar:" + keyword + "\n\
|
|
xmlns:bar='http://localhost/' id='17'/>\n\
|
|
<bar:" + keyword + " xmlns:bar='http://localhost/'>\n\
|
|
<bunk/>\n\
|
|
</bar:" + keyword + "></>)\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 = <foo xmlns:bar='http://localhost/'>\
|
|
<fin bar:" + keyword + "='5'/>\
|
|
</foo>;\n\
|
|
if (x.fin.@bar::" + keyword + " != 5)\n\
|
|
throw 'namespaced attributes which are keywords are broken!';");
|
|
}
|
|
catch (e)
|
|
{
|
|
throw e;
|
|
}
|
|
},
|
|
CONTEXT_XML_ATTRIBUTE_SELECTOR:
|
|
function(keyword)
|
|
{
|
|
try
|
|
{
|
|
eval("var x = <foo " + keyword + "='idref'/>;\n\
|
|
if (x.@" + keyword + " != 'idref')\n\
|
|
throw 'keywords on the right of the @ E4X selector 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);
|