1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
* Date: 28 May 2001
*
* SUMMARY: Functions are scoped statically, not dynamically
*
* See ECMA Section 10.1.4 Scope Chain and Identifier Resolution
* (This section defines the scope chain of an execution context)
*
* See ECMA Section 12.10 The with Statement
*
* See ECMA Section 13 Function Definition
* (This section defines the scope chain of a function object as that
* of the running execution context when the function was declared)
*
* Like scope-001.js, but using assignment var f = function expression
* instead of a function declaration: function f() {} etc.
*/
//-----------------------------------------------------------------------------
var UBound = 0;
var BUGNUMBER = '(none)';
var summary = 'Testing that functions are scoped statically, not dynamically';
var self = this; // capture a reference to the global object
var status = '';
var statusitems = [ ];
var actual = '';
var actualvalues = [ ];
var expect= '';
var expectedvalues = [ ];
/*
* In this section the expected value is 1, not 2.
*
* Why? f captures its scope chain from when it's declared, and imposes that chain
* when it's executed. In other words, f's scope chain is from when it was compiled.
* Since f is a top-level function, this is the global object only. Hence 'a' resolves to 1.
*/
status = 'Section A of test';
var a = 1;
var f = function () {return a;};
var obj = {a:2};
with (obj)
{
actual = f();
}
expect = 1;
addThis();
/*
* In this section the expected value is 2, not 1. That is because here
* f's associated scope chain now includes 'obj' before the global object.
*/
status = 'Section B of test';
var a = 1;
var obj = {a:2};
with (obj)
{
var f = function () {return a;};
actual = f();
}
expect = 2;
addThis();
/*
* Like Section B , except that we call f outside the with block.
* By the principles explained above, we still expect 2 -
*/
status = 'Section C of test';
var a = 1;
var obj = {a:2};
with (obj)
{
var f = function () {return a;};
}
actual = f();
expect = 2;
addThis();
/*
* Like Section C, but with one more level of indirection -
*/
status = 'Section D of test';
var a = 1;
var obj = {a:2, obj:{a:3}};
with (obj)
{
with (obj)
{
var f = function () {return a;};
}
}
actual = f();
expect = 3;
addThis();
/*
* Like Section C, but here we actually delete obj before calling f.
* We still expect 2 -
*/
status = 'Section E of test';
var a = 1;
var obj = {a:2};
with (obj)
{
var f = function () {return a;};
}
delete obj;
actual = f();
expect = 2;
addThis();
/*
* Like Section E. Here we redefine obj and call f under with (obj) -
* We still expect 2 -
*/
status = 'Section F of test';
var a = 1;
var obj = {a:2};
with (obj)
{
var f = function () {return a;};
}
delete obj;
var obj = {a:3};
with (obj)
{
actual = f();
}
expect = 2; // NOT 3 !!!
addThis();
/*
* Explicitly verify that f exists at global level, even though
* it was defined under the with(obj) block -
*/
status = 'Section G of test';
var a = 1;
var obj = {a:2};
with (obj)
{
var f = function () {return a;};
}
actual = String([obj.hasOwnProperty('f'), self.hasOwnProperty('f')]);
expect = String([false, true]);
addThis();
/*
* Explicitly verify that f exists at global level, even though
* it was defined under the with(obj) block -
*/
status = 'Section H of test';
var a = 1;
var obj = {a:2};
with (obj)
{
var f = function () {return a;};
}
actual = String(['f' in obj, 'f' in self]);
expect = String([false, true]);
addThis();
//-------------------------------------------------------------------------------------------------
test();
//-------------------------------------------------------------------------------------------------
function addThis()
{
statusitems[UBound] = status;
actualvalues[UBound] = actual;
expectedvalues[UBound] = expect;
UBound++;
resetTestVars();
}
function resetTestVars()
{
delete a;
delete obj;
delete f;
}
function test()
{
enterFunc ('test');
printBugNumber(BUGNUMBER);
printStatus (summary);
for (var i = 0; i < UBound; i++)
{
reportCompare(expectedvalues[i], actualvalues[i], statusitems[i]);
}
exitFunc ('test');
}
|
