js/tests/js1_7/lexical/regress-336376-01.js

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is JavaScript Engine testing utilities.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Jeff Walden <jwalden+code@mit.edu>.
  19  * Portions created by the Initial Developer are Copyright (C) 2006
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 var gTestfile = 'regress-336376-01.js';
  39 //-----------------------------------------------------------------------------
  40 var BUGNUMBER     = "336376";
  41 var summary = "Tests reserved words in contexts in which they are not reserved";
  42 var actual, expect;
  43
  44 printBugNumber(BUGNUMBER);
  45 printStatus(summary);
  46
  47 /**************
  48  * TEST SETUP *
  49  **************/
  50
  51 //
  52 // New tests go in Tester.prototype._tests.  A test is called with a single
  53 // argument, the keyword to test in the syntax tested by that test.  Tests
  54 // should not return anything, and they should signal failure by throwing an
  55 // explanatory exception and success by not throwing one.
  56 //
  57 // If you define a new test, make sure to name it using an informative string
  58 // for ease of use if any keywords ever manually define the array of tests they
  59 // should pass, and add it as a string to ALL_TESTS.
  60 //
  61
  62 // all tests
  63 const ALL_TESTS =
  64   [
  65     "CONTEXT_OBJECT_LITERAL_PROPERTY",
  66     "CONTEXT_OBJECT_PROPERTY_DOT_REFERENCE",
  67     "CONTEXT_OBJECT_PROPERTY_DOT_REFERENCE_IS_FUNCTION",
  68     "CONTEXT_OBJECT_PROPERTY_DOT_GET",
  69     "CONTEXT_OBJECT_PROPERTY_DOT_SET",
  70     "CONTEXT_XML_DESCENDANTS",
  71     "CONTEXT_XML_NAMESPACE_QUALIFIED_ELEMENT",
  72     "CONTEXT_XML_NAMESPACE_QUALIFIED_ATTR",
  73     "CONTEXT_XML_ATTRIBUTE_SELECTOR",
  74     ];
  75
  76 function r(keyword, tests)
  77 {
  78   /**
  79    * @param keyword
  80    *   the keyword as a string
  81    * @param tests
  82    *   array of test numbers against it, or leave undefined to run all tests
  83    *   against it
  84    */
  85   function Reserved(keyword, tests)
  86   {
  87     this.keyword = keyword;
  88     if (tests)
  89       this.tests = tests;
  90     else
  91       this.tests = ALL_TESTS;
  92   }
  93   Reserved.prototype =
  94     {
  95       toString:
  96       function()
  97       {
  98         return "'" + this.keyword + "' being run against tests " +
  99         this.tests;
 100       }
 101     };
 102   return new Reserved(keyword, tests);
 103 }
 104
 105 // ECMA-262, 3rd. ed. keywords -- see 7.5.2
 106 const ECMA_262_3_KEYWORD =
 107   [
 108     r("break"),
 109     r("case"),
 110     r("catch"),
 111     r("continue"),
 112     r("default"),
 113     r("delete"),
 114     r("do"),
 115     r("else"),
 116     r("finally"),
 117     r("for"),
 118     r("function"),
 119     r("if"),
 120     r("in"),
 121     r("instanceof"),
 122     r("new"),
 123     r("return"),
 124     r("switch"),
 125     r("this"),
 126     r("throw"),
 127     r("try"),
 128     r("typeof"),
 129     r("var"),
 130     r("void"),
 131     r("while"),
 132     r("with"),
 133     ];
 134
 135 // ECMA-262, 3rd. ed. future reserved keywords -- see 7.5.3
 136 const ECMA_262_3_FUTURERESERVEDKEYWORD =
 137   [
 138     r("abstract"),
 139     r("boolean"),
 140     r("byte"),
 141     r("char"),
 142     r("class"),
 143     r("const"),
 144     r("debugger"),
 145     r("double"),
 146     r("enum"),
 147     r("export"),
 148     r("extends"),
 149     r("final"),
 150     r("float"),
 151     r("goto"),
 152     r("implements"),
 153     r("import"),
 154     r("int"),
 155     r("interface"),
 156     r("long"),
 157     r("native"),
 158     r("package"),
 159     r("private"),
 160     r("protected"),
 161     r("public"),
 162     r("short"),
 163     r("static"),
 164     r("super"),
 165     r("synchronized"),
 166     r("throws"),
 167     r("transient"),
 168     r("volatile"),
 169     ];
 170
 171 // like reserved words, but not quite reserved words
 172 const PSEUDO_RESERVED =
 173   [
 174     r("true"),
 175     r("false"),
 176     r("null"),
 177     r("each"),  // |for each|
 178     ];
 179
 180 // new-in-ES4 reserved words -- fill this as each is implemented
 181 const ECMA_262_4_RESERVED_WORDS =
 182   [
 183     r("let")
 184     ];
 185
 186
 187
 188 /**
 189  * @param keyword
 190  *   string containing the tested keyword
 191  * @param test
 192  *   the number of the failing test
 193  * @param error
 194  *   the exception thrown when running the test
 195  */
 196 function Failure(keyword, test, error)
 197 {
 198   this.keyword = keyword;
 199   this.test = test;
 200   this.error = error;
 201 }
 202 Failure.prototype =
 203 {
 204   toString:
 205   function()
 206   {
 207     return "*** FAILURE on '" + this.keyword + "'!\n" +
 208     "* test:     " + this.test + "\n" +
 209     "* error:    " + this.error + "\n";
 210   }
 211 };
 212
 213 function Tester()
 214 {
 215   this._failedTests = [];
 216 }
 217 Tester.prototype =
 218 {
 219   testReservedWords:
 220   function(reservedArray)
 221   {
 222     var rv;
 223     for (var i = 0, sz = reservedArray.length; i < sz; i++)
 224     {
 225       var res = reservedArray[i];
 226       if (!res)
 227         continue;
 228
 229       var tests = res.tests;
 230       for (var j = 0, sz2 = tests.length; j < sz2; j++)
 231       {
 232         var test = tests[j];
 233         if (!test)
 234           continue;
 235
 236         try
 237         {
 238           this._tests[test](res.keyword);
 239         }
 240         catch (e)
 241         {
 242           this._failedTests.push(new Failure(res.keyword, test, e));
 243         }
 244       }
 245     }
 246   },
 247   flushErrors:
 248   function ()
 249   {
 250     if (this._failedTests.length > 0) {
 251       var except = "*************************\n" +
 252       "* FAILURES ENCOUNTERED! *\n" +
 253       "*************************\n";
 254       for (var i = 0, sz = this._failedTests.length; i < sz; i++)
 255         except += this._failedTests[i];
 256       throw except;
 257     }
 258   },
 259   _tests:
 260   {
 261     CONTEXT_OBJECT_LITERAL_PROPERTY:
 262     function(keyword)
 263     {
 264       try
 265       {
 266         eval("var o = { " + keyword + ": 17 };\n" +
 267              "if (o['" + keyword + "'] != 17)\n" +
 268              "throw \"o['" + keyword + "'] == 17\";");
 269       }
 270       catch (e)
 271       {
 272         throw e;
 273       }
 274     },
 275     CONTEXT_OBJECT_PROPERTY_DOT_REFERENCE:
 276     function(keyword)
 277     {
 278       try
 279       {
 280         eval("var o = { \"" + keyword + "\": 17, baz: null };\n" +
 281              "if (o." + keyword + " != 17)\n" +
 282              "throw \"o." + keyword + " == 17\";");
 283       }
 284       catch (e)
 285       {
 286         throw e;
 287       }
 288     },
 289     CONTEXT_OBJECT_PROPERTY_DOT_REFERENCE_IS_FUNCTION:
 290     function(keyword)
 291     {
 292       try
 293       {
 294         eval("var o = { '" + keyword + "': function() { return 17; }, baz: null };\n" +
 295              "if (o." + keyword + "() != 17)\n" +
 296              "throw \"o." + keyword + " == 17\";");
 297       }
 298       catch (e)
 299       {
 300         throw e;
 301       }
 302     },
 303     CONTEXT_OBJECT_PROPERTY_DOT_GET:
 304     function(keyword)
 305     {
 306       try
 307       {
 308         var o = {};
 309         eval("o['" + keyword + "'] = 17;\n" +
 310              "if (o." + keyword + " != 17)\n" +
 311              "throw \"'o." + keyword + " != 17' failed!\";");
 312       }
 313       catch (e)
 314       {
 315         throw e;
 316       }
 317     },
 318     CONTEXT_OBJECT_PROPERTY_DOT_SET:
 319     function(keyword)
 320     {
 321       try
 322       {
 323         var o = {};
 324         eval("o." + keyword + " = 17;\n" +
 325              "if (o['" + keyword + "'] != 17)\n" +
 326              "throw \"'o." + keyword + " = 17' failed!\";");
 327       }
 328       catch (e)
 329       {
 330         throw e;
 331       }
 332     },
 333     CONTEXT_XML_DESCENDANTS:
 334     function(keyword)
 335     {
 336       try
 337       {
 338         eval("var x = <foo><biz><" + keyword + " id='1'/></biz><" + keyword + " f='g'/></foo>;\n" +
 339              "if (x.." + keyword + ".length() != 2 ||\n" +
 340              "    x.." + keyword + " !=              \n" +
 341              "      <><" + keyword + " id='1'/><" + keyword + " f='g'/></>)\n" +
 342              "throw \"'x.." + keyword + ".length()' failed!\";");
 343       }
 344       catch (e)
 345       {
 346         throw e;
 347       }
 348     },
 349     CONTEXT_XML_NAMESPACE_QUALIFIED_ELEMENT:
 350     function(keyword)
 351     {
 352       try
 353       {
 354         var bar = new Namespace("http://localhost/");
 355         eval("var x = <foo xmlns:bar='http://localhost/'>\n\
 356                               <bar>\n\
 357                                 <baz/>\n\
 358                               </bar>\n\
 359                               <bar:" + keyword + " id='17'/>\n\
 360                               <quiz>\n\
 361                                 <bar:" + keyword + ">\n\
 362                                   <bunk/>\n\
 363                                 </bar:" + keyword + ">\n\
 364                               </quiz>\n\
 365                             </foo>;\n\
 366                     if (x.quiz.bar::" + keyword + " != \n\
 367                           <bar:" + keyword + "  xmlns:bar='http://localhost/'>\n\
 368                             <bunk/>\n\
 369                           </bar:" + keyword + "> ||\n\
 370                         x..bar::" + keyword + " != \n\
 371                             <><bar:" + keyword + "\n\
 372                                 xmlns:bar='http://localhost/' id='17'/>\n\
 373                               <bar:" + keyword + " xmlns:bar='http://localhost/'>\n\
 374                                 <bunk/>\n\
 375                               </bar:" + keyword + "></>)\n\
 376                       throw 'reserved names in XML namespace-qualified stuff are broken!';");
 377       }
 378       catch (e)
 379       {
 380         throw e;
 381       }
 382     },
 383     CONTEXT_XML_NAMESPACE_QUALIFIED_ATTR:
 384     function(keyword)
 385     {
 386       try
 387       {
 388         var bar = new Namespace("http://localhost/");
 389         eval("var x = <foo xmlns:bar='http://localhost/'>\
 390                               <fin bar:" + keyword + "='5'/>\
 391                             </foo>;\n\
 392                     if (x.fin.@bar::" + keyword + " != 5)\n\
 393                       throw 'namespaced attributes which are keywords are broken!';");
 394       }
 395       catch (e)
 396       {
 397         throw e;
 398       }
 399     },
 400     CONTEXT_XML_ATTRIBUTE_SELECTOR:
 401     function(keyword)
 402     {
 403       try
 404       {
 405         eval("var x = <foo " + keyword + "='idref'/>;\n\
 406                     if (x.@" + keyword + " != 'idref')\n\
 407                       throw 'keywords on the right of the @ E4X selector are broken!';");
 408       }
 409       catch (e)
 410       {
 411         throw e;
 412       }
 413     }
 414   }
 415 };
 416
 417
 418 /***************
 419  * BEGIN TESTS *
 420  ***************/
 421
 422 var failed = false;
 423
 424 try
 425 {
 426   var tester = new Tester();
 427   tester.testReservedWords(ECMA_262_3_KEYWORD);
 428   tester.testReservedWords(ECMA_262_3_FUTURERESERVEDKEYWORD);
 429   tester.testReservedWords(PSEUDO_RESERVED);
 430   tester.testReservedWords(ECMA_262_4_RESERVED_WORDS);
 431   tester.flushErrors();
 432 }
 433 catch (e)
 434 {
 435   failed = e;
 436 }
 437
 438 expect = false;
 439 actual = failed;
 440
 441 reportCompare(expect, actual, summary);