The Tor Browser / file comparison
comparison: js/src/tests/ecma_5/strict/13.1.js
js/src/tests/ecma_5/strict/13.1.js
- branch
- TOR_BUG_3246
- changeset 5
- 4ab42b5ab56c
equal
deleted
inserted
replaced
| -1:000000000000 | 0:252a4fe0e4e9 |
|---|---|
| 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); |
