1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/js/src/tests/ecma_5/Function/strict-arguments.js Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,453 @@
1.4 +/*
1.5 + * Any copyright is dedicated to the Public Domain.
1.6 + * http://creativecommons.org/licenses/publicdomain/
1.7 + */
1.8 +
1.9 +var gTestfile = 'strict-arguments.js';
1.10 +var BUGNUMBER = 516255;
1.11 +var summary =
1.12 + "ES5 strict mode: arguments objects of strict mode functions must copy " +
1.13 + "argument values";
1.14 +
1.15 +print(BUGNUMBER + ": " + summary);
1.16 +
1.17 +/**************
1.18 + * BEGIN TEST *
1.19 + **************/
1.20 +
1.21 +function arrayEvery(arr, fun)
1.22 +{
1.23 + return Array.prototype.every.call(arr, fun);
1.24 +}
1.25 +
1.26 +function arraysEqual(a1, a2)
1.27 +{
1.28 + return a1.length === a2.length &&
1.29 + arrayEvery(a1, function(v, i) { return v === a2[i]; });
1.30 +}
1.31 +
1.32 +
1.33 +/************************
1.34 + * NON-STRICT ARGUMENTS *
1.35 + ************************/
1.36 +
1.37 +var obj = {};
1.38 +
1.39 +function noargs() { return arguments; }
1.40 +
1.41 +assertEq(arraysEqual(noargs(), []), true);
1.42 +assertEq(arraysEqual(noargs(1), [1]), true);
1.43 +assertEq(arraysEqual(noargs(2, obj, 8), [2, obj, 8]), true);
1.44 +
1.45 +function args(a) { return arguments; }
1.46 +
1.47 +assertEq(arraysEqual(args(), []), true);
1.48 +assertEq(arraysEqual(args(1), [1]), true);
1.49 +assertEq(arraysEqual(args(1, obj), [1, obj]), true);
1.50 +assertEq(arraysEqual(args("foopy"), ["foopy"]), true);
1.51 +
1.52 +function assign(a)
1.53 +{
1.54 + a = 17;
1.55 + return arguments;
1.56 +}
1.57 +
1.58 +assertEq(arraysEqual(assign(1), [17]), true);
1.59 +
1.60 +function getLaterAssign(a)
1.61 +{
1.62 + var o = arguments;
1.63 + a = 17;
1.64 + return o;
1.65 +}
1.66 +
1.67 +assertEq(arraysEqual(getLaterAssign(1), [17]), true);
1.68 +
1.69 +function assignElementGetParameter(a)
1.70 +{
1.71 + arguments[0] = 17;
1.72 + return a;
1.73 +}
1.74 +
1.75 +assertEq(assignElementGetParameter(42), 17);
1.76 +
1.77 +function assignParameterGetElement(a)
1.78 +{
1.79 + a = 17;
1.80 + return arguments[0];
1.81 +}
1.82 +
1.83 +assertEq(assignParameterGetElement(42), 17);
1.84 +
1.85 +function assignArgSub(x, y)
1.86 +{
1.87 + arguments[0] = 3;
1.88 + return arguments[0];
1.89 +}
1.90 +
1.91 +assertEq(assignArgSub(1), 3);
1.92 +
1.93 +function assignArgSubParamUse(x, y)
1.94 +{
1.95 + arguments[0] = 3;
1.96 + assertEq(x, 3);
1.97 + return arguments[0];
1.98 +}
1.99 +
1.100 +assertEq(assignArgSubParamUse(1), 3);
1.101 +
1.102 +function assignArgumentsElement(x, y)
1.103 +{
1.104 + arguments[0] = 3;
1.105 + return arguments[Math.random() ? "0" : 0]; // nix arguments[const] optimizations
1.106 +}
1.107 +
1.108 +assertEq(assignArgumentsElement(1), 3);
1.109 +
1.110 +function assignArgumentsElementParamUse(x, y)
1.111 +{
1.112 + arguments[0] = 3;
1.113 + assertEq(x, 3);
1.114 + return arguments[Math.random() ? "0" : 0]; // nix arguments[const] optimizations
1.115 +}
1.116 +
1.117 +assertEq(assignArgumentsElementParamUse(1), 3);
1.118 +
1.119 +/********************
1.120 + * STRICT ARGUMENTS *
1.121 + ********************/
1.122 +
1.123 +function strictNoargs()
1.124 +{
1.125 + "use strict";
1.126 + return arguments;
1.127 +}
1.128 +
1.129 +assertEq(arraysEqual(strictNoargs(), []), true);
1.130 +assertEq(arraysEqual(strictNoargs(1), [1]), true);
1.131 +assertEq(arraysEqual(strictNoargs(1, obj), [1, obj]), true);
1.132 +
1.133 +function strictArgs(a)
1.134 +{
1.135 + "use strict";
1.136 + return arguments;
1.137 +}
1.138 +
1.139 +assertEq(arraysEqual(strictArgs(), []), true);
1.140 +assertEq(arraysEqual(strictArgs(1), [1]), true);
1.141 +assertEq(arraysEqual(strictArgs(1, obj), [1, obj]), true);
1.142 +
1.143 +function strictAssign(a)
1.144 +{
1.145 + "use strict";
1.146 + a = 17;
1.147 + return arguments;
1.148 +}
1.149 +
1.150 +assertEq(arraysEqual(strictAssign(), []), true);
1.151 +assertEq(arraysEqual(strictAssign(1), [1]), true);
1.152 +assertEq(arraysEqual(strictAssign(1, obj), [1, obj]), true);
1.153 +
1.154 +var upper;
1.155 +function strictAssignAfter(a)
1.156 +{
1.157 + "use strict";
1.158 + upper = arguments;
1.159 + a = 42;
1.160 + return upper;
1.161 +}
1.162 +
1.163 +assertEq(arraysEqual(strictAssignAfter(), []), true);
1.164 +assertEq(arraysEqual(strictAssignAfter(17), [17]), true);
1.165 +assertEq(arraysEqual(strictAssignAfter(obj), [obj]), true);
1.166 +
1.167 +function strictMaybeAssignOuterParam(p)
1.168 +{
1.169 + "use strict";
1.170 + function inner() { p = 17; }
1.171 + return arguments;
1.172 +}
1.173 +
1.174 +assertEq(arraysEqual(strictMaybeAssignOuterParam(), []), true);
1.175 +assertEq(arraysEqual(strictMaybeAssignOuterParam(42), [42]), true);
1.176 +assertEq(arraysEqual(strictMaybeAssignOuterParam(obj), [obj]), true);
1.177 +
1.178 +function strictAssignOuterParam(p)
1.179 +{
1.180 + "use strict";
1.181 + function inner() { p = 17; }
1.182 + inner();
1.183 + return arguments;
1.184 +}
1.185 +
1.186 +assertEq(arraysEqual(strictAssignOuterParam(), []), true);
1.187 +assertEq(arraysEqual(strictAssignOuterParam(17), [17]), true);
1.188 +assertEq(arraysEqual(strictAssignOuterParam(obj), [obj]), true);
1.189 +
1.190 +function strictAssignOuterParamPSYCH(p)
1.191 +{
1.192 + "use strict";
1.193 + function inner(p) { p = 17; }
1.194 + inner();
1.195 + return arguments;
1.196 +}
1.197 +
1.198 +assertEq(arraysEqual(strictAssignOuterParamPSYCH(), []), true);
1.199 +assertEq(arraysEqual(strictAssignOuterParamPSYCH(17), [17]), true);
1.200 +assertEq(arraysEqual(strictAssignOuterParamPSYCH(obj), [obj]), true);
1.201 +
1.202 +function strictEval(code, p)
1.203 +{
1.204 + "use strict";
1.205 + eval(code);
1.206 + return arguments;
1.207 +}
1.208 +
1.209 +assertEq(arraysEqual(strictEval("1", 2), ["1", 2]), true);
1.210 +assertEq(arraysEqual(strictEval("arguments"), ["arguments"]), true);
1.211 +assertEq(arraysEqual(strictEval("p = 2"), ["p = 2"]), true);
1.212 +assertEq(arraysEqual(strictEval("p = 2", 17), ["p = 2", 17]), true);
1.213 +assertEq(arraysEqual(strictEval("arguments[0] = 17"), [17]), true);
1.214 +assertEq(arraysEqual(strictEval("arguments[0] = 17", 42), [17, 42]), true);
1.215 +
1.216 +function strictMaybeNestedEval(code, p)
1.217 +{
1.218 + "use strict";
1.219 + function inner() { eval(code); }
1.220 + return arguments;
1.221 +}
1.222 +
1.223 +assertEq(arraysEqual(strictMaybeNestedEval("1", 2), ["1", 2]), true);
1.224 +assertEq(arraysEqual(strictMaybeNestedEval("arguments"), ["arguments"]), true);
1.225 +assertEq(arraysEqual(strictMaybeNestedEval("p = 2"), ["p = 2"]), true);
1.226 +assertEq(arraysEqual(strictMaybeNestedEval("p = 2", 17), ["p = 2", 17]), true);
1.227 +
1.228 +function strictNestedEval(code, p)
1.229 +{
1.230 + "use strict";
1.231 + function inner() { eval(code); }
1.232 + inner();
1.233 + return arguments;
1.234 +}
1.235 +
1.236 +assertEq(arraysEqual(strictNestedEval("1", 2), ["1", 2]), true);
1.237 +assertEq(arraysEqual(strictNestedEval("arguments"), ["arguments"]), true);
1.238 +assertEq(arraysEqual(strictNestedEval("p = 2"), ["p = 2"]), true);
1.239 +assertEq(arraysEqual(strictNestedEval("p = 2", 17), ["p = 2", 17]), true);
1.240 +assertEq(arraysEqual(strictNestedEval("arguments[0] = 17"), ["arguments[0] = 17"]), true);
1.241 +assertEq(arraysEqual(strictNestedEval("arguments[0] = 17", 42), ["arguments[0] = 17", 42]), true);
1.242 +
1.243 +function strictAssignArguments(a)
1.244 +{
1.245 + "use strict";
1.246 + arguments[0] = 42;
1.247 + return a;
1.248 +}
1.249 +
1.250 +assertEq(strictAssignArguments(), undefined);
1.251 +assertEq(strictAssignArguments(obj), obj);
1.252 +assertEq(strictAssignArguments(17), 17);
1.253 +
1.254 +function strictAssignParameterGetElement(a)
1.255 +{
1.256 + "use strict";
1.257 + a = 17;
1.258 + return arguments[0];
1.259 +}
1.260 +
1.261 +assertEq(strictAssignParameterGetElement(42), 42);
1.262 +
1.263 +function strictAssignArgSub(x, y)
1.264 +{
1.265 + "use strict";
1.266 + arguments[0] = 3;
1.267 + return arguments[0];
1.268 +}
1.269 +
1.270 +assertEq(strictAssignArgSub(1), 3);
1.271 +
1.272 +function strictAssignArgSubParamUse(x, y)
1.273 +{
1.274 + "use strict";
1.275 + arguments[0] = 3;
1.276 + assertEq(x, 1);
1.277 + return arguments[0];
1.278 +}
1.279 +
1.280 +assertEq(strictAssignArgSubParamUse(1), 3);
1.281 +
1.282 +function strictAssignArgumentsElement(x, y)
1.283 +{
1.284 + "use strict";
1.285 + arguments[0] = 3;
1.286 + return arguments[Math.random() ? "0" : 0]; // nix arguments[const] optimizations
1.287 +}
1.288 +
1.289 +assertEq(strictAssignArgumentsElement(1), 3);
1.290 +
1.291 +function strictAssignArgumentsElementParamUse(x, y)
1.292 +{
1.293 + "use strict";
1.294 + arguments[0] = 3;
1.295 + assertEq(x, 1);
1.296 + return arguments[Math.random() ? "0" : 0]; // nix arguments[const] optimizations
1.297 +}
1.298 +
1.299 +assertEq(strictAssignArgumentsElementParamUse(1), 3);
1.300 +
1.301 +function strictNestedAssignShadowVar(p)
1.302 +{
1.303 + "use strict";
1.304 + function inner()
1.305 + {
1.306 + var p = 12;
1.307 + function innermost() { p = 1776; return 12; }
1.308 + return innermost();
1.309 + }
1.310 + return arguments;
1.311 +}
1.312 +
1.313 +assertEq(arraysEqual(strictNestedAssignShadowVar(), []), true);
1.314 +assertEq(arraysEqual(strictNestedAssignShadowVar(99), [99]), true);
1.315 +assertEq(arraysEqual(strictNestedAssignShadowVar(""), [""]), true);
1.316 +assertEq(arraysEqual(strictNestedAssignShadowVar(obj), [obj]), true);
1.317 +
1.318 +function strictNestedAssignShadowCatch(p)
1.319 +{
1.320 + "use strict";
1.321 + function inner()
1.322 + {
1.323 + try
1.324 + {
1.325 + }
1.326 + catch (p)
1.327 + {
1.328 + var f = function innermost() { p = 1776; return 12; };
1.329 + f();
1.330 + }
1.331 + }
1.332 + return arguments;
1.333 +}
1.334 +
1.335 +assertEq(arraysEqual(strictNestedAssignShadowCatch(), []), true);
1.336 +assertEq(arraysEqual(strictNestedAssignShadowCatch(99), [99]), true);
1.337 +assertEq(arraysEqual(strictNestedAssignShadowCatch(""), [""]), true);
1.338 +assertEq(arraysEqual(strictNestedAssignShadowCatch(obj), [obj]), true);
1.339 +
1.340 +function strictNestedAssignShadowCatchCall(p)
1.341 +{
1.342 + "use strict";
1.343 + function inner()
1.344 + {
1.345 + try
1.346 + {
1.347 + }
1.348 + catch (p)
1.349 + {
1.350 + var f = function innermost() { p = 1776; return 12; };
1.351 + f();
1.352 + }
1.353 + }
1.354 + inner();
1.355 + return arguments;
1.356 +}
1.357 +
1.358 +assertEq(arraysEqual(strictNestedAssignShadowCatchCall(), []), true);
1.359 +assertEq(arraysEqual(strictNestedAssignShadowCatchCall(99), [99]), true);
1.360 +assertEq(arraysEqual(strictNestedAssignShadowCatchCall(""), [""]), true);
1.361 +assertEq(arraysEqual(strictNestedAssignShadowCatchCall(obj), [obj]), true);
1.362 +
1.363 +function strictNestedAssignShadowFunction(p)
1.364 +{
1.365 + "use strict";
1.366 + function inner()
1.367 + {
1.368 + function p() { }
1.369 + p = 1776;
1.370 + }
1.371 + return arguments;
1.372 +}
1.373 +
1.374 +assertEq(arraysEqual(strictNestedAssignShadowFunction(), []), true);
1.375 +assertEq(arraysEqual(strictNestedAssignShadowFunction(99), [99]), true);
1.376 +assertEq(arraysEqual(strictNestedAssignShadowFunction(""), [""]), true);
1.377 +assertEq(arraysEqual(strictNestedAssignShadowFunction(obj), [obj]), true);
1.378 +
1.379 +function strictNestedAssignShadowFunctionCall(p)
1.380 +{
1.381 + "use strict";
1.382 + function inner()
1.383 + {
1.384 + function p() { }
1.385 + p = 1776;
1.386 + }
1.387 + return arguments;
1.388 +}
1.389 +
1.390 +assertEq(arraysEqual(strictNestedAssignShadowFunctionCall(), []), true);
1.391 +assertEq(arraysEqual(strictNestedAssignShadowFunctionCall(99), [99]), true);
1.392 +assertEq(arraysEqual(strictNestedAssignShadowFunctionCall(""), [""]), true);
1.393 +assertEq(arraysEqual(strictNestedAssignShadowFunctionCall(obj), [obj]), true);
1.394 +
1.395 +function strictNestedShadowAndMaybeEval(code, p)
1.396 +{
1.397 + "use strict";
1.398 + function inner(p) { eval(code); }
1.399 + return arguments;
1.400 +}
1.401 +
1.402 +assertEq(arraysEqual(strictNestedShadowAndMaybeEval("1", 2), ["1", 2]), true);
1.403 +assertEq(arraysEqual(strictNestedShadowAndMaybeEval("arguments"), ["arguments"]), true);
1.404 +assertEq(arraysEqual(strictNestedShadowAndMaybeEval("p = 2"), ["p = 2"]), true);
1.405 +assertEq(arraysEqual(strictNestedShadowAndMaybeEval("p = 2", 17), ["p = 2", 17]), true);
1.406 +assertEq(arraysEqual(strictNestedShadowAndMaybeEval("arguments[0] = 17"), ["arguments[0] = 17"]), true);
1.407 +assertEq(arraysEqual(strictNestedShadowAndMaybeEval("arguments[0] = 17", 42), ["arguments[0] = 17", 42]), true);
1.408 +
1.409 +function strictNestedShadowAndEval(code, p)
1.410 +{
1.411 + "use strict";
1.412 + function inner(p) { eval(code); }
1.413 + return arguments;
1.414 +}
1.415 +
1.416 +assertEq(arraysEqual(strictNestedShadowAndEval("1", 2), ["1", 2]), true);
1.417 +assertEq(arraysEqual(strictNestedShadowAndEval("arguments"), ["arguments"]), true);
1.418 +assertEq(arraysEqual(strictNestedShadowAndEval("p = 2"), ["p = 2"]), true);
1.419 +assertEq(arraysEqual(strictNestedShadowAndEval("p = 2", 17), ["p = 2", 17]), true);
1.420 +assertEq(arraysEqual(strictNestedShadowAndEval("arguments[0] = 17"), ["arguments[0] = 17"]), true);
1.421 +assertEq(arraysEqual(strictNestedShadowAndEval("arguments[0] = 17", 42), ["arguments[0] = 17", 42]), true);
1.422 +
1.423 +function strictEvalContainsMutation(code)
1.424 +{
1.425 + "use strict";
1.426 + return eval(code);
1.427 +}
1.428 +
1.429 +assertEq(arraysEqual(strictEvalContainsMutation("code = 17; arguments"), ["code = 17; arguments"]), true);
1.430 +assertEq(arraysEqual(strictEvalContainsMutation("arguments[0] = 17; arguments"), [17]), true);
1.431 +assertEq(strictEvalContainsMutation("arguments[0] = 17; code"), "arguments[0] = 17; code");
1.432 +
1.433 +function strictNestedAssignShadowFunctionName(p)
1.434 +{
1.435 + "use strict";
1.436 + function inner()
1.437 + {
1.438 + function p() { p = 1776; }
1.439 + p();
1.440 + }
1.441 + inner();
1.442 + return arguments;
1.443 +}
1.444 +
1.445 +assertEq(arraysEqual(strictNestedAssignShadowFunctionName(), []), true);
1.446 +assertEq(arraysEqual(strictNestedAssignShadowFunctionName(99), [99]), true);
1.447 +assertEq(arraysEqual(strictNestedAssignShadowFunctionName(""), [""]), true);
1.448 +assertEq(arraysEqual(strictNestedAssignShadowFunctionName(obj), [obj]), true);
1.449 +
1.450 +
1.451 +/******************************************************************************/
1.452 +
1.453 +if (typeof reportCompare === "function")
1.454 + reportCompare(true, true);
1.455 +
1.456 +print("All tests passed!");
