tests/auto/declarative/parserstress/tests/ecma_3/Function/scope-001.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 //-----------------------------------------------------------------------------
  54 var gTestfile = 'scope-001.js';
  55 var UBound = 0;
  56 var BUGNUMBER = '(none)';
  57 var summary = 'Testing that functions are scoped statically, not dynamically';
  58 var self = this;  // capture a reference to the global object
  59 var status = '';
  60 var statusitems = [ ];
  61 var actual = '';
  62 var actualvalues = [ ];
  63 var expect= '';
  64 var expectedvalues = [ ];
  65
  66 /*
  67  * In this section the expected value is 1, not 2.
  68  *
  69  * Why? f captures its scope chain from when it's declared, and imposes that chain
  70  * when it's executed. In other words, f's scope chain is from when it was compiled.
  71  * Since f is a top-level function, this is the global object only. Hence 'a' resolves to 1.
  72  */
  73 status = 'Section A of test';
  74 var a = 1;
  75 function f()
  76 {
  77   return a;
  78 }
  79 var obj = {a:2};
  80 with (obj)
  81 {
  82   actual = f();
  83 }
  84 expect = 1;
  85 addThis();
  86
  87
  88 /*
  89  * In this section the expected value is 2, not 1. That is because here
  90  * f's associated scope chain now includes 'obj' before the global object.
  91  */
  92 status = 'Section B of test';
  93 var a = 1;
  94 var obj = {a:2};
  95 with (obj)
  96 {
  97   function f()
  98   {
  99     return a;
 100   }
 101   actual = f();
 102 }
 103 expect = 2;
 104 addThis();
 105
 106
 107 /*
 108  * Like Section B , except that we call f outside the with block.
 109  * By the principles explained above, we still expect 2 -
 110  */
 111 status = 'Section C of test';
 112 var a = 1;
 113 var obj = {a:2};
 114 with (obj)
 115 {
 116   function f()
 117   {
 118     return a;
 119   }
 120 }
 121 actual = f();
 122 expect = 2;
 123 addThis();
 124
 125
 126 /*
 127  * Like Section C, but with one more level of indirection -
 128  */
 129 status = 'Section D of test';
 130 var a = 1;
 131 var obj = {a:2, obj:{a:3}};
 132 with (obj)
 133 {
 134   with (obj)
 135   {
 136     function f()
 137     {
 138       return a;
 139     }
 140   }
 141 }
 142 actual = f();
 143 expect = 3;
 144 addThis();
 145
 146
 147 /*
 148  * Like Section C, but here we actually delete obj before calling f.
 149  * We still expect 2 -
 150  */
 151 status = 'Section E of test';
 152 var a = 1;
 153 var obj = {a:2};
 154 with (obj)
 155 {
 156   function f()
 157   {
 158     return a;
 159   }
 160 }
 161 delete obj;
 162 actual = f();
 163 expect = 2;
 164 addThis();
 165
 166
 167 /*
 168  * Like Section E. Here we redefine obj and call f under with (obj) -
 169  * We still expect 2 -
 170  */
 171 status = 'Section F of test';
 172 var a = 1;
 173 var obj = {a:2};
 174 with (obj)
 175 {
 176   function f()
 177   {
 178     return a;
 179   }
 180 }
 181 delete obj;
 182 var obj = {a:3};
 183 with (obj)
 184 {
 185   actual = f();
 186 }
 187 expect = 2;  // NOT 3 !!!
 188 addThis();
 189
 190
 191 /*
 192  * Explicitly verify that f exists at global level, even though
 193  * it was defined under the with(obj) block -
 194  */
 195 status = 'Section G of test';
 196 var a = 1;
 197 var obj = {a:2};
 198 with (obj)
 199 {
 200   function f()
 201   {
 202     return a;
 203   }
 204 }
 205 actual = String([obj.hasOwnProperty('f'), self.hasOwnProperty('f')]);
 206 expect = String([false, true]);
 207 addThis();
 208
 209
 210 /*
 211  * Explicitly verify that f exists at global level, even though
 212  * it was defined under the with(obj) block -
 213  */
 214 status = 'Section H of test';
 215 var a = 1;
 216 var obj = {a:2};
 217 with (obj)
 218 {
 219   function f()
 220   {
 221     return a;
 222   }
 223 }
 224 actual = String(['f' in obj, 'f' in self]);
 225 expect = String([false, true]);
 226 addThis();
 227
 228
 229
 230 //-------------------------------------------------------------------------------------------------
 231 test();
 232 //-------------------------------------------------------------------------------------------------
 233
 234
 235 function addThis()
 236 {
 237   statusitems[UBound] = status;
 238   actualvalues[UBound] = actual;
 239   expectedvalues[UBound] = expect;
 240   UBound++;
 241   resetTestVars();
 242 }
 243
 244
 245 function resetTestVars()
 246 {
 247   delete a;
 248   delete obj;
 249   delete f;
 250 }
 251
 252
 253 function test()
 254 {
 255   enterFunc ('test');
 256   printBugNumber(BUGNUMBER);
 257   printStatus (summary);
 258
 259   for (var i = 0; i < UBound; i++)
 260   {
 261     reportCompare(expectedvalues[i], actualvalues[i], statusitems[i]);
 262   }
 263
 264   exitFunc ('test');
 265 }