js/src/tests/ecma_5/Function/strict-arguments.js

   1 /*
   2  * Any copyright is dedicated to the Public Domain.
   3  * http://creativecommons.org/licenses/publicdomain/
   4  */
   5
   6 var gTestfile = 'strict-arguments.js';
   7 var BUGNUMBER = 516255;
   8 var summary =
   9   "ES5 strict mode: arguments objects of strict mode functions must copy " +
  10   "argument values";
  11
  12 print(BUGNUMBER + ": " + summary);
  13
  14 /**************
  15  * BEGIN TEST *
  16  **************/
  17
  18 function arrayEvery(arr, fun)
  19 {
  20   return Array.prototype.every.call(arr, fun);
  21 }
  22
  23 function arraysEqual(a1, a2)
  24 {
  25   return a1.length === a2.length &&
  26          arrayEvery(a1, function(v, i) { return v === a2[i]; });
  27 }
  28
  29
  30 /************************
  31  * NON-STRICT ARGUMENTS *
  32  ************************/
  33
  34 var obj = {};
  35
  36 function noargs() { return arguments; }
  37
  38 assertEq(arraysEqual(noargs(), []), true);
  39 assertEq(arraysEqual(noargs(1), [1]), true);
  40 assertEq(arraysEqual(noargs(2, obj, 8), [2, obj, 8]), true);
  41
  42 function args(a) { return arguments; }
  43
  44 assertEq(arraysEqual(args(), []), true);
  45 assertEq(arraysEqual(args(1), [1]), true);
  46 assertEq(arraysEqual(args(1, obj), [1, obj]), true);
  47 assertEq(arraysEqual(args("foopy"), ["foopy"]), true);
  48
  49 function assign(a)
  50 {
  51   a = 17;
  52   return arguments;
  53 }
  54
  55 assertEq(arraysEqual(assign(1), [17]), true);
  56
  57 function getLaterAssign(a)
  58 {
  59   var o = arguments;
  60   a = 17;
  61   return o;
  62 }
  63
  64 assertEq(arraysEqual(getLaterAssign(1), [17]), true);
  65
  66 function assignElementGetParameter(a)
  67 {
  68   arguments[0] = 17;
  69   return a;
  70 }
  71
  72 assertEq(assignElementGetParameter(42), 17);
  73
  74 function assignParameterGetElement(a)
  75 {
  76   a = 17;
  77   return arguments[0];
  78 }
  79
  80 assertEq(assignParameterGetElement(42), 17);
  81
  82
  83 /********************
  84  * STRICT ARGUMENTS *
  85  ********************/
  86
  87 function strictNoargs()
  88 {
  89   "use strict";
  90   return arguments;
  91 }
  92
  93 assertEq(arraysEqual(strictNoargs(), []), true);
  94 assertEq(arraysEqual(strictNoargs(1), [1]), true);
  95 assertEq(arraysEqual(strictNoargs(1, obj), [1, obj]), true);
  96
  97 function strictArgs(a)
  98 {
  99   "use strict";
 100   return arguments;
 101 }
 102
 103 assertEq(arraysEqual(strictArgs(), []), true);
 104 assertEq(arraysEqual(strictArgs(1), [1]), true);
 105 assertEq(arraysEqual(strictArgs(1, obj), [1, obj]), true);
 106
 107 function strictAssign(a)
 108 {
 109   "use strict";
 110   a = 17;
 111   return arguments;
 112 }
 113
 114 assertEq(arraysEqual(strictAssign(), []), true);
 115 assertEq(arraysEqual(strictAssign(1), [1]), true);
 116 assertEq(arraysEqual(strictAssign(1, obj), [1, obj]), true);
 117
 118 var upper;
 119 function strictAssignAfter(a)
 120 {
 121   "use strict";
 122   upper = arguments;
 123   a = 42;
 124   return upper;
 125 }
 126
 127 assertEq(arraysEqual(strictAssignAfter(), []), true);
 128 assertEq(arraysEqual(strictAssignAfter(17), [17]), true);
 129 assertEq(arraysEqual(strictAssignAfter(obj), [obj]), true);
 130
 131 function strictMaybeAssignOuterParam(p)
 132 {
 133   "use strict";
 134   function inner() { p = 17; }
 135   return arguments;
 136 }
 137
 138 assertEq(arraysEqual(strictMaybeAssignOuterParam(), []), true);
 139 assertEq(arraysEqual(strictMaybeAssignOuterParam(42), [42]), true);
 140 assertEq(arraysEqual(strictMaybeAssignOuterParam(obj), [obj]), true);
 141
 142 function strictAssignOuterParam(p)
 143 {
 144   "use strict";
 145   function inner() { p = 17; }
 146   inner();
 147   return arguments;
 148 }
 149
 150 assertEq(arraysEqual(strictAssignOuterParam(), []), true);
 151 assertEq(arraysEqual(strictAssignOuterParam(17), [17]), true);
 152 assertEq(arraysEqual(strictAssignOuterParam(obj), [obj]), true);
 153
 154 function strictAssignOuterParamPSYCH(p)
 155 {
 156   "use strict";
 157   function inner(p) { p = 17; }
 158   inner();
 159   return arguments;
 160 }
 161
 162 assertEq(arraysEqual(strictAssignOuterParamPSYCH(), []), true);
 163 assertEq(arraysEqual(strictAssignOuterParamPSYCH(17), [17]), true);
 164 assertEq(arraysEqual(strictAssignOuterParamPSYCH(obj), [obj]), true);
 165
 166 function strictEval(code, p)
 167 {
 168   "use strict";
 169   eval(code);
 170   return arguments;
 171 }
 172
 173 assertEq(arraysEqual(strictEval("1", 2), ["1", 2]), true);
 174 assertEq(arraysEqual(strictEval("arguments"), ["arguments"]), true);
 175 assertEq(arraysEqual(strictEval("p = 2"), ["p = 2"]), true);
 176 assertEq(arraysEqual(strictEval("p = 2", 17), ["p = 2", 17]), true);
 177 assertEq(arraysEqual(strictEval("arguments[0] = 17"), [17]), true);
 178 assertEq(arraysEqual(strictEval("arguments[0] = 17", 42), [17, 42]), true);
 179
 180 function strictMaybeNestedEval(code, p)
 181 {
 182   "use strict";
 183   function inner() { eval(code); }
 184   return arguments;
 185 }
 186
 187 assertEq(arraysEqual(strictMaybeNestedEval("1", 2), ["1", 2]), true);
 188 assertEq(arraysEqual(strictMaybeNestedEval("arguments"), ["arguments"]), true);
 189 assertEq(arraysEqual(strictMaybeNestedEval("p = 2"), ["p = 2"]), true);
 190 assertEq(arraysEqual(strictMaybeNestedEval("p = 2", 17), ["p = 2", 17]), true);
 191
 192 function strictNestedEval(code, p)
 193 {
 194   "use strict";
 195   function inner() { eval(code); }
 196   inner();
 197   return arguments;
 198 }
 199
 200 assertEq(arraysEqual(strictNestedEval("1", 2), ["1", 2]), true);
 201 assertEq(arraysEqual(strictNestedEval("arguments"), ["arguments"]), true);
 202 assertEq(arraysEqual(strictNestedEval("p = 2"), ["p = 2"]), true);
 203 assertEq(arraysEqual(strictNestedEval("p = 2", 17), ["p = 2", 17]), true);
 204 assertEq(arraysEqual(strictNestedEval("arguments[0] = 17"), ["arguments[0] = 17"]), true);
 205 assertEq(arraysEqual(strictNestedEval("arguments[0] = 17", 42), ["arguments[0] = 17", 42]), true);
 206
 207 function strictAssignArguments(a)
 208 {
 209   "use strict";
 210   arguments[0] = 42;
 211   return a;
 212 }
 213
 214 assertEq(strictAssignArguments(), undefined);
 215 assertEq(strictAssignArguments(obj), obj);
 216 assertEq(strictAssignArguments(17), 17);
 217
 218 function strictAssignParameterGetElement(a)
 219 {
 220   "use strict";
 221   a = 17;
 222   return arguments[0];
 223 }
 224
 225 assertEq(strictAssignParameterGetElement(42), 42);
 226
 227 function strictNestedAssignShadowVar(p)
 228 {
 229   "use strict";
 230   function inner()
 231   {
 232     var p = 12;
 233     function innermost() { p = 1776; return 12; }
 234     return innermost();
 235   }
 236   return arguments;
 237 }
 238
 239 assertEq(arraysEqual(strictNestedAssignShadowVar(), []), true);
 240 assertEq(arraysEqual(strictNestedAssignShadowVar(99), [99]), true);
 241 assertEq(arraysEqual(strictNestedAssignShadowVar(""), [""]), true);
 242 assertEq(arraysEqual(strictNestedAssignShadowVar(obj), [obj]), true);
 243
 244 function strictNestedAssignShadowCatch(p)
 245 {
 246   "use strict";
 247   function inner()
 248   {
 249     try
 250     {
 251     }
 252     catch (p)
 253     {
 254       var f = function innermost() { p = 1776; return 12; };
 255       f();
 256     }
 257   }
 258   return arguments;
 259 }
 260
 261 assertEq(arraysEqual(strictNestedAssignShadowCatch(), []), true);
 262 assertEq(arraysEqual(strictNestedAssignShadowCatch(99), [99]), true);
 263 assertEq(arraysEqual(strictNestedAssignShadowCatch(""), [""]), true);
 264 assertEq(arraysEqual(strictNestedAssignShadowCatch(obj), [obj]), true);
 265
 266 function strictNestedAssignShadowCatchCall(p)
 267 {
 268   "use strict";
 269   function inner()
 270   {
 271     try
 272     {
 273     }
 274     catch (p)
 275     {
 276       var f = function innermost() { p = 1776; return 12; };
 277       f();
 278     }
 279   }
 280   inner();
 281   return arguments;
 282 }
 283
 284 assertEq(arraysEqual(strictNestedAssignShadowCatchCall(), []), true);
 285 assertEq(arraysEqual(strictNestedAssignShadowCatchCall(99), [99]), true);
 286 assertEq(arraysEqual(strictNestedAssignShadowCatchCall(""), [""]), true);
 287 assertEq(arraysEqual(strictNestedAssignShadowCatchCall(obj), [obj]), true);
 288
 289 function strictNestedAssignShadowFunction(p)
 290 {
 291   "use strict";
 292   function inner()
 293   {
 294     function p() { }
 295     p = 1776;
 296   }
 297   return arguments;
 298 }
 299
 300 assertEq(arraysEqual(strictNestedAssignShadowFunction(), []), true);
 301 assertEq(arraysEqual(strictNestedAssignShadowFunction(99), [99]), true);
 302 assertEq(arraysEqual(strictNestedAssignShadowFunction(""), [""]), true);
 303 assertEq(arraysEqual(strictNestedAssignShadowFunction(obj), [obj]), true);
 304
 305 function strictNestedAssignShadowFunctionCall(p)
 306 {
 307   "use strict";
 308   function inner()
 309   {
 310     function p() { }
 311     p = 1776;
 312   }
 313   return arguments;
 314 }
 315
 316 assertEq(arraysEqual(strictNestedAssignShadowFunctionCall(), []), true);
 317 assertEq(arraysEqual(strictNestedAssignShadowFunctionCall(99), [99]), true);
 318 assertEq(arraysEqual(strictNestedAssignShadowFunctionCall(""), [""]), true);
 319 assertEq(arraysEqual(strictNestedAssignShadowFunctionCall(obj), [obj]), true);
 320
 321 function strictNestedShadowAndMaybeEval(code, p)
 322 {
 323   "use strict";
 324   function inner(p) { eval(code); }
 325   return arguments;
 326 }
 327
 328 assertEq(arraysEqual(strictNestedShadowAndMaybeEval("1", 2), ["1", 2]), true);
 329 assertEq(arraysEqual(strictNestedShadowAndMaybeEval("arguments"), ["arguments"]), true);
 330 assertEq(arraysEqual(strictNestedShadowAndMaybeEval("p = 2"), ["p = 2"]), true);
 331 assertEq(arraysEqual(strictNestedShadowAndMaybeEval("p = 2", 17), ["p = 2", 17]), true);
 332 assertEq(arraysEqual(strictNestedShadowAndMaybeEval("arguments[0] = 17"), ["arguments[0] = 17"]), true);
 333 assertEq(arraysEqual(strictNestedShadowAndMaybeEval("arguments[0] = 17", 42), ["arguments[0] = 17", 42]), true);
 334
 335 function strictNestedShadowAndEval(code, p)
 336 {
 337   "use strict";
 338   function inner(p) { eval(code); }
 339   return arguments;
 340 }
 341
 342 assertEq(arraysEqual(strictNestedShadowAndEval("1", 2), ["1", 2]), true);
 343 assertEq(arraysEqual(strictNestedShadowAndEval("arguments"), ["arguments"]), true);
 344 assertEq(arraysEqual(strictNestedShadowAndEval("p = 2"), ["p = 2"]), true);
 345 assertEq(arraysEqual(strictNestedShadowAndEval("p = 2", 17), ["p = 2", 17]), true);
 346 assertEq(arraysEqual(strictNestedShadowAndEval("arguments[0] = 17"), ["arguments[0] = 17"]), true);
 347 assertEq(arraysEqual(strictNestedShadowAndEval("arguments[0] = 17", 42), ["arguments[0] = 17", 42]), true);
 348
 349 function strictEvalContainsMutation(code)
 350 {
 351   "use strict";
 352   return eval(code);
 353 }
 354
 355 assertEq(arraysEqual(strictEvalContainsMutation("code = 17; arguments"), ["code = 17; arguments"]), true);
 356 assertEq(arraysEqual(strictEvalContainsMutation("arguments[0] = 17; arguments"), [17]), true);
 357 assertEq(strictEvalContainsMutation("arguments[0] = 17; code"), "arguments[0] = 17; code");
 358
 359 function strictNestedAssignShadowFunctionName(p)
 360 {
 361   "use strict";
 362   function inner()
 363   {
 364     function p() { p = 1776; }
 365     p();
 366   }
 367   inner();
 368   return arguments;
 369 }
 370
 371 assertEq(arraysEqual(strictNestedAssignShadowFunctionName(), []), true);
 372 assertEq(arraysEqual(strictNestedAssignShadowFunctionName(99), [99]), true);
 373 assertEq(arraysEqual(strictNestedAssignShadowFunctionName(""), [""]), true);
 374 assertEq(arraysEqual(strictNestedAssignShadowFunctionName(obj), [obj]), true);
 375
 376
 377 /******************************************************************************/
 378
 379 if (typeof reportCompare === "function")
 380   reportCompare(true, true);
 381
 382 print("All tests passed!");