tests/auto/declarative/parserstress/tests/ecma_3/Function/scope-002.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 mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   pschwartau@netscape.com, rogerl@netscape.com
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 /*
  40  * Date: 28 May 2001
  41  *
  42  * SUMMARY:  Functions are scoped statically, not dynamically
  43  *
  44  * See ECMA Section 10.1.4 Scope Chain and Identifier Resolution
  45  * (This section defines the scope chain of an execution context)
  46  *
  47  * See ECMA Section 12.10 The with Statement
  48  *
  49  * See ECMA Section 13 Function Definition
  50  * (This section defines the scope chain of a function object as that
  51  *  of the running execution context when the function was declared)
  52  *
  53  * Like scope-001.js, but using assignment var f = function expression
  54  * instead of a function declaration: function f() {} etc.
  55  */
  56 //-----------------------------------------------------------------------------
  57 var gTestfile = 'scope-002.js';
  58 var UBound = 0;
  59 var BUGNUMBER = '(none)';
  60 var summary = 'Testing that functions are scoped statically, not dynamically';
  61 var self = this;  // capture a reference to the global object
  62 var status = '';
  63 var statusitems = [ ];
  64 var actual = '';
  65 var actualvalues = [ ];
  66 var expect= '';
  67 var expectedvalues = [ ];
  68
  69
  70 /*
  71  * In this section the expected value is 1, not 2.
  72  *
  73  * Why? f captures its scope chain from when it's declared, and imposes that chain
  74  * when it's executed. In other words, f's scope chain is from when it was compiled.
  75  * Since f is a top-level function, this is the global object only. Hence 'a' resolves to 1.
  76  */
  77 status = 'Section A of test';
  78 var a = 1;
  79 var f = function () {return a;};
  80 var obj = {a:2};
  81 with (obj)
  82 {
  83   actual = f();
  84 }
  85 expect = 1;
  86 addThis();
  87
  88
  89 /*
  90  * In this section the expected value is 2, not 1. That is because here
  91  * f's associated scope chain now includes 'obj' before the global object.
  92  */
  93 status = 'Section B of test';
  94 var a = 1;
  95 var obj = {a:2};
  96 with (obj)
  97 {
  98   var f = function () {return a;};
  99   actual = f();
 100 }
 101 expect = 2;
 102 addThis();
 103
 104
 105 /*
 106  * Like Section B , except that we call f outside the with block.
 107  * By the principles explained above, we still expect 2 -
 108  */
 109 status = 'Section C of test';
 110 var a = 1;
 111 var obj = {a:2};
 112 with (obj)
 113 {
 114   var f = function () {return a;};
 115 }
 116 actual = f();
 117 expect = 2;
 118 addThis();
 119
 120
 121 /*
 122  * Like Section C, but with one more level of indirection -
 123  */
 124 status = 'Section D of test';
 125 var a = 1;
 126 var obj = {a:2, obj:{a:3}};
 127 with (obj)
 128 {
 129   with (obj)
 130   {
 131     var f = function () {return a;};
 132   }
 133 }
 134 actual = f();
 135 expect = 3;
 136 addThis();
 137
 138
 139 /*
 140  * Like Section C, but here we actually delete obj before calling f.
 141  * We still expect 2 -
 142  */
 143 status = 'Section E of test';
 144 var a = 1;
 145 var obj = {a:2};
 146 with (obj)
 147 {
 148   var f = function () {return a;};
 149 }
 150 delete obj;
 151 actual = f();
 152 expect = 2;
 153 addThis();
 154
 155
 156 /*
 157  * Like Section E. Here we redefine obj and call f under with (obj) -
 158  * We still expect 2 -
 159  */
 160 status = 'Section F of test';
 161 var a = 1;
 162 var obj = {a:2};
 163 with (obj)
 164 {
 165   var f = function () {return a;};
 166 }
 167 delete obj;
 168 var obj = {a:3};
 169 with (obj)
 170 {
 171   actual = f();
 172 }
 173 expect = 2;  // NOT 3 !!!
 174 addThis();
 175
 176
 177 /*
 178  * Explicitly verify that f exists at global level, even though
 179  * it was defined under the with(obj) block -
 180  */
 181 status = 'Section G of test';
 182 var a = 1;
 183 var obj = {a:2};
 184 with (obj)
 185 {
 186   var f = function () {return a;};
 187 }
 188 actual = String([obj.hasOwnProperty('f'), self.hasOwnProperty('f')]);
 189 expect = String([false, true]);
 190 addThis();
 191
 192
 193 /*
 194  * Explicitly verify that f exists at global level, even though
 195  * it was defined under the with(obj) block -
 196  */
 197 status = 'Section H of test';
 198 var a = 1;
 199 var obj = {a:2};
 200 with (obj)
 201 {
 202   var f = function () {return a;};
 203 }
 204 actual = String(['f' in obj, 'f' in self]);
 205 expect = String([false, true]);
 206 addThis();
 207
 208
 209
 210 //-------------------------------------------------------------------------------------------------
 211 test();
 212 //-------------------------------------------------------------------------------------------------
 213
 214
 215 function addThis()
 216 {
 217   statusitems[UBound] = status;
 218   actualvalues[UBound] = actual;
 219   expectedvalues[UBound] = expect;
 220   UBound++;
 221   resetTestVars();
 222 }
 223
 224
 225 function resetTestVars()
 226 {
 227   delete a;
 228   delete obj;
 229   delete f;
 230 }
 231
 232
 233 function test()
 234 {
 235   enterFunc ('test');
 236   printBugNumber(BUGNUMBER);
 237   printStatus (summary);
 238
 239   for (var i = 0; i < UBound; i++)
 240   {
 241     reportCompare(expectedvalues[i], actualvalues[i], statusitems[i]);
 242   }
 243
 244   exitFunc ('test');
 245 }