js/src/tests/ecma_5/strict/13.1.js

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2
   3 /*
   4  * Any copyright is dedicated to the Public Domain.
   5  * http://creativecommons.org/licenses/publicdomain/
   6  */
   7
   8 /*
   9  * In strict mode, it is a syntax error for an identifier to appear
  10  * more than once in a function's argument list.
  11  */
  12
  13 /*
  14  * The parameters of ordinary function definitions should not contain
  15  * duplicate identifiers.
  16  */
  17 assertEq(testLenientAndStrict('function f(x,y) {}',
  18                               parsesSuccessfully,
  19                               parsesSuccessfully),
  20          true);
  21 assertEq(testLenientAndStrict('function f(x,x) {}',
  22                               parsesSuccessfully,
  23                               parseRaisesException(SyntaxError)),
  24          true);
  25 assertEq(testLenientAndStrict('function f(x,y,z,y) {}',
  26                               parsesSuccessfully,
  27                               parseRaisesException(SyntaxError)),
  28          true);
  29
  30 /* Exercise the hashed local name map case. */
  31 assertEq(testLenientAndStrict('function f(a,b,c,d,e,f,g,h,d) {}',
  32                               parsesSuccessfully,
  33                               parseRaisesException(SyntaxError)),
  34          true);
  35
  36 /*
  37  * SpiderMonkey has always treated duplicates in destructuring
  38  * patterns as an error. Strict mode should not affect this.
  39  */
  40 assertEq(testLenientAndStrict('function f([x,y]) {}',
  41                               parsesSuccessfully,
  42                               parsesSuccessfully),
  43          true);
  44 assertEq(testLenientAndStrict('function f([x,x]){}',
  45                               parseRaisesException(SyntaxError),
  46                               parseRaisesException(SyntaxError)),
  47          true);
  48 assertEq(testLenientAndStrict('function f(x,[x]){}',
  49                               parseRaisesException(SyntaxError),
  50                               parseRaisesException(SyntaxError)),
  51          true);
  52
  53 /*
  54  * Strict rules apply to the parameters if the function's body is
  55  * strict.
  56  */
  57 assertEq(testLenientAndStrict('function f(x,x) { "use strict" };',
  58                               parseRaisesException(SyntaxError),
  59                               parseRaisesException(SyntaxError)),
  60          true);
  61
  62 /*
  63  * Calls to the function constructor should not be affected by the
  64  * strictness of the calling code, but should be affected by the
  65  * strictness of the function body.
  66  */
  67 assertEq(testLenientAndStrict('Function("x","x","")',
  68                               completesNormally,
  69                               completesNormally),
  70          true);
  71 assertEq(testLenientAndStrict('Function("x","y","")',
  72                               completesNormally,
  73                               completesNormally),
  74          true);
  75 assertEq(testLenientAndStrict('Function("x","x","\'use strict\'")',
  76                               raisesException(SyntaxError),
  77                               raisesException(SyntaxError)),
  78          true);
  79 assertEq(testLenientAndStrict('Function("x","y","\'use strict\'")',
  80                               completesNormally,
  81                               completesNormally),
  82          true);
  83
  84
  85 /*
  86  * The parameter lists of function expressions should not contain
  87  * duplicate identifiers.
  88  */
  89 assertEq(testLenientAndStrict('(function (x,x) 2)',
  90                                parsesSuccessfully,
  91                                parseRaisesException(SyntaxError)),
  92          true);
  93 assertEq(testLenientAndStrict('(function (x,y) 2)',
  94                               parsesSuccessfully,
  95                               parsesSuccessfully),
  96          true);
  97
  98 /*
  99  * All permutations of:
 100  * - For the two magic identifiers 'arguments' or 'eval'
 101  *   - For function definitions, function expressions, expression closures,
 102  *     and getter and setter property definitions,
 103  *     - For forms that inherit their context's strictness, and forms that
 104  *       include their own strictness directives,
 105  *       - For ordinary parameters, array destructuring parameters, and
 106  *         object destructuring parameters,
 107  *         - the magic identifiers may be used to name such parameters
 108  *           in lenient code, but not in strict code
 109  *       - the magic identifiers may be used as function names in lenient code,
 110  *         but not in strict code
 111  */
 112 assertEq(testLenientAndStrict('function f(eval){}',
 113                               parsesSuccessfully,
 114                               parseRaisesException(SyntaxError)),
 115          true);
 116 assertEq(testLenientAndStrict('function f([eval]){}',
 117                               parsesSuccessfully,
 118                               parseRaisesException(SyntaxError)),
 119          true);
 120 assertEq(testLenientAndStrict('function f({x:eval}){}',
 121                               parsesSuccessfully,
 122                               parseRaisesException(SyntaxError)),
 123          true);
 124 assertEq(testLenientAndStrict('function eval(){}',
 125                               parsesSuccessfully,
 126                               parseRaisesException(SyntaxError)),
 127          true);
 128 assertEq(testLenientAndStrict('function f(eval){"use strict";}',
 129                               parseRaisesException(SyntaxError),
 130                               parseRaisesException(SyntaxError)),
 131          true);
 132 assertEq(testLenientAndStrict('function f([eval]){"use strict";}',
 133                               parseRaisesException(SyntaxError),
 134                               parseRaisesException(SyntaxError)),
 135          true);
 136 assertEq(testLenientAndStrict('function f({x:eval}){"use strict";}',
 137                               parseRaisesException(SyntaxError),
 138                               parseRaisesException(SyntaxError)),
 139          true);
 140 assertEq(testLenientAndStrict('function eval(){"use strict";}',
 141                               parseRaisesException(SyntaxError),
 142                               parseRaisesException(SyntaxError)),
 143          true);
 144 assertEq(testLenientAndStrict('(function f(eval){})',
 145                               parsesSuccessfully,
 146                               parseRaisesException(SyntaxError)),
 147          true);
 148 assertEq(testLenientAndStrict('(function f([eval]){})',
 149                               parsesSuccessfully,
 150                               parseRaisesException(SyntaxError)),
 151          true);
 152 assertEq(testLenientAndStrict('(function f({x:eval}){})',
 153                               parsesSuccessfully,
 154                               parseRaisesException(SyntaxError)),
 155          true);
 156 assertEq(testLenientAndStrict('(function eval(){})',
 157                               parsesSuccessfully,
 158                               parseRaisesException(SyntaxError)),
 159          true);
 160 assertEq(testLenientAndStrict('(function f(eval){"use strict";})',
 161                               parseRaisesException(SyntaxError),
 162                               parseRaisesException(SyntaxError)),
 163          true);
 164 assertEq(testLenientAndStrict('(function f([eval]){"use strict";})',
 165                               parseRaisesException(SyntaxError),
 166                               parseRaisesException(SyntaxError)),
 167          true);
 168 assertEq(testLenientAndStrict('(function f({x:eval}){"use strict";})',
 169                               parseRaisesException(SyntaxError),
 170                               parseRaisesException(SyntaxError)),
 171          true);
 172 assertEq(testLenientAndStrict('(function eval(){"use strict";})',
 173                               parseRaisesException(SyntaxError),
 174                               parseRaisesException(SyntaxError)),
 175          true);
 176 assertEq(testLenientAndStrict('(function f(eval) 2)',
 177                               parsesSuccessfully,
 178                               parseRaisesException(SyntaxError)),
 179          true);
 180 assertEq(testLenientAndStrict('(function f([eval]) 2)',
 181                               parsesSuccessfully,
 182                               parseRaisesException(SyntaxError)),
 183          true);
 184 assertEq(testLenientAndStrict('(function f({x:eval}) 2)',
 185                               parsesSuccessfully,
 186                               parseRaisesException(SyntaxError)),
 187          true);
 188 assertEq(testLenientAndStrict('(function eval() 2)',
 189                               parsesSuccessfully,
 190                               parseRaisesException(SyntaxError)),
 191          true);
 192 assertEq(testLenientAndStrict('({set x(eval){}})',
 193                               parsesSuccessfully,
 194                               parseRaisesException(SyntaxError)),
 195          true);
 196 assertEq(testLenientAndStrict('({set x([eval]){}})',
 197                               parsesSuccessfully,
 198                               parseRaisesException(SyntaxError)),
 199          true);
 200 assertEq(testLenientAndStrict('({set x({x:eval}){}})',
 201                               parsesSuccessfully,
 202                               parseRaisesException(SyntaxError)),
 203          true);
 204 assertEq(testLenientAndStrict('({set x(eval){"use strict";}})',
 205                               parseRaisesException(SyntaxError),
 206                               parseRaisesException(SyntaxError)),
 207          true);
 208 assertEq(testLenientAndStrict('({set x([eval]){"use strict";}})',
 209                               parseRaisesException(SyntaxError),
 210                               parseRaisesException(SyntaxError)),
 211          true);
 212 assertEq(testLenientAndStrict('({set x({x:eval}){"use strict";}})',
 213                               parseRaisesException(SyntaxError),
 214                               parseRaisesException(SyntaxError)),
 215          true);
 216 assertEq(testLenientAndStrict('function f(arguments){}',
 217                               parsesSuccessfully,
 218                               parseRaisesException(SyntaxError)),
 219          true);
 220 assertEq(testLenientAndStrict('function f([arguments]){}',
 221                               parsesSuccessfully,
 222                               parseRaisesException(SyntaxError)),
 223          true);
 224 assertEq(testLenientAndStrict('function f({x:arguments}){}',
 225                               parsesSuccessfully,
 226                               parseRaisesException(SyntaxError)),
 227          true);
 228 assertEq(testLenientAndStrict('function arguments(){}',
 229                               parsesSuccessfully,
 230                               parseRaisesException(SyntaxError)),
 231          true);
 232 assertEq(testLenientAndStrict('function f(arguments){"use strict";}',
 233                               parseRaisesException(SyntaxError),
 234                               parseRaisesException(SyntaxError)),
 235          true);
 236 assertEq(testLenientAndStrict('function f([arguments]){"use strict";}',
 237                               parseRaisesException(SyntaxError),
 238                               parseRaisesException(SyntaxError)),
 239          true);
 240 assertEq(testLenientAndStrict('function f({x:arguments}){"use strict";}',
 241                               parseRaisesException(SyntaxError),
 242                               parseRaisesException(SyntaxError)),
 243          true);
 244 assertEq(testLenientAndStrict('function arguments(){"use strict";}',
 245                               parseRaisesException(SyntaxError),
 246                               parseRaisesException(SyntaxError)),
 247          true);
 248 assertEq(testLenientAndStrict('(function f(arguments){})',
 249                               parsesSuccessfully,
 250                               parseRaisesException(SyntaxError)),
 251          true);
 252 assertEq(testLenientAndStrict('(function f([arguments]){})',
 253                               parsesSuccessfully,
 254                               parseRaisesException(SyntaxError)),
 255          true);
 256 assertEq(testLenientAndStrict('(function f({x:arguments}){})',
 257                               parsesSuccessfully,
 258                               parseRaisesException(SyntaxError)),
 259          true);
 260 assertEq(testLenientAndStrict('(function arguments(){})',
 261                               parsesSuccessfully,
 262                               parseRaisesException(SyntaxError)),
 263          true);
 264 assertEq(testLenientAndStrict('(function f(arguments){"use strict";})',
 265                               parseRaisesException(SyntaxError),
 266                               parseRaisesException(SyntaxError)),
 267          true);
 268 assertEq(testLenientAndStrict('(function f([arguments]){"use strict";})',
 269                               parseRaisesException(SyntaxError),
 270                               parseRaisesException(SyntaxError)),
 271          true);
 272 assertEq(testLenientAndStrict('(function f({x:arguments}){"use strict";})',
 273                               parseRaisesException(SyntaxError),
 274                               parseRaisesException(SyntaxError)),
 275          true);
 276 assertEq(testLenientAndStrict('(function arguments(){"use strict";})',
 277                               parseRaisesException(SyntaxError),
 278                               parseRaisesException(SyntaxError)),
 279          true);
 280 assertEq(testLenientAndStrict('(function f(arguments) 2)',
 281                               parsesSuccessfully,
 282                               parseRaisesException(SyntaxError)),
 283          true);
 284 assertEq(testLenientAndStrict('(function f([arguments]) 2)',
 285                               parsesSuccessfully,
 286                               parseRaisesException(SyntaxError)),
 287          true);
 288 assertEq(testLenientAndStrict('(function f({x:arguments}) 2)',
 289                               parsesSuccessfully,
 290                               parseRaisesException(SyntaxError)),
 291          true);
 292 assertEq(testLenientAndStrict('(function arguments() 2)',
 293                               parsesSuccessfully,
 294                               parseRaisesException(SyntaxError)),
 295          true);
 296 assertEq(testLenientAndStrict('({set x(arguments){}})',
 297                               parsesSuccessfully,
 298                               parseRaisesException(SyntaxError)),
 299          true);
 300 assertEq(testLenientAndStrict('({set x([arguments]){}})',
 301                               parsesSuccessfully,
 302                               parseRaisesException(SyntaxError)),
 303          true);
 304 assertEq(testLenientAndStrict('({set x({x:arguments}){}})',
 305                               parsesSuccessfully,
 306                               parseRaisesException(SyntaxError)),
 307          true);
 308 assertEq(testLenientAndStrict('({set x(arguments){"use strict";}})',
 309                               parseRaisesException(SyntaxError),
 310                               parseRaisesException(SyntaxError)),
 311          true);
 312 assertEq(testLenientAndStrict('({set x([arguments]){"use strict";}})',
 313                               parseRaisesException(SyntaxError),
 314                               parseRaisesException(SyntaxError)),
 315          true);
 316 assertEq(testLenientAndStrict('({set x({x:arguments}){"use strict";}})',
 317                               parseRaisesException(SyntaxError),
 318                               parseRaisesException(SyntaxError)),
 319          true);
 320
 321 /*
 322  * Functions produced using the Function constructor may not use
 323  * 'eval' or 'arguments' as a parameter name if their body is strict
 324  * mode code. The strictness of the calling code does not affect the
 325  * constraints applied to the parameters.
 326  */
 327 assertEq(testLenientAndStrict('Function("eval","")',
 328                               completesNormally,
 329                               completesNormally),
 330          true);
 331 assertEq(testLenientAndStrict('Function("eval","\'use strict\';")',
 332                               raisesException(SyntaxError),
 333                               raisesException(SyntaxError)),
 334          true);
 335 assertEq(testLenientAndStrict('Function("arguments","")',
 336                               completesNormally,
 337                               completesNormally),
 338          true);
 339 assertEq(testLenientAndStrict('Function("arguments","\'use strict\';")',
 340                               raisesException(SyntaxError),
 341                               raisesException(SyntaxError)),
 342          true);
 343
 344
 345 reportCompare(true, true);