Debian Codegraph @

closure-library/closure/goog/disposable/disposable_test.js

raw
1 // Copyright 2008 The Closure Library Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS-IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 goog.provide('goog.DisposableTest');
16 goog.setTestOnly('goog.DisposableTest');
17
18 goog.require('goog.Disposable');
19 goog.require('goog.testing.jsunit');
20 goog.require('goog.testing.recordFunction');
21 var d1, d2;
22
23 // Sample subclass of goog.Disposable.
24
25 function DisposableTest() {
26 goog.Disposable.call(this);
27 this.element = document.getElementById('someElement');
28 }
29 goog.inherits(DisposableTest, goog.Disposable);
30
31 DisposableTest.prototype.disposeInternal = function() {
32 DisposableTest.superClass_.disposeInternal.call(this);
33 delete this.element;
34 };
35
36 // Class that doesn't inherit from goog.Disposable, but implements the
37 // disposable interface via duck typing.
38
39 function DisposableDuck() {
40 this.element = document.getElementById('someElement');
41 }
42
43 DisposableDuck.prototype.dispose = function() {
44 delete this.element;
45 };
46
47 // Class which calls dispose recursively.
48
49 function RecursiveDisposable() {
50 this.disposedCount = 0;
51 }
52 goog.inherits(RecursiveDisposable, goog.Disposable);
53
54 RecursiveDisposable.prototype.disposeInternal = function() {
55 ++this.disposedCount;
56 assertEquals('Disposed too many times', 1, this.disposedCount);
57 this.dispose();
58 };
59
60 // Test methods.
61
62 function setUp() {
63 d1 = new goog.Disposable();
64 d2 = new DisposableTest();
65 }
66
67 function tearDown() {
68 goog.Disposable.MONITORING_MODE = goog.Disposable.MonitoringMode.OFF;
69 goog.Disposable.INCLUDE_STACK_ON_CREATION = true;
70 goog.Disposable.instances_ = {};
71 d1.dispose();
72 d2.dispose();
73 }
74
75 function testConstructor() {
76 assertFalse(d1.isDisposed());
77 assertFalse(d2.isDisposed());
78 assertEquals(document.getElementById('someElement'), d2.element);
79 }
80
81 function testDispose() {
82 assertFalse(d1.isDisposed());
83 d1.dispose();
84 assertTrue(
85 'goog.Disposable instance should have been disposed of', d1.isDisposed());
86
87 assertFalse(d2.isDisposed());
88 d2.dispose();
89 assertTrue(
90 'goog.DisposableTest instance should have been disposed of',
91 d2.isDisposed());
92 }
93
94 function testDisposeInternal() {
95 assertNotUndefined(d2.element);
96 d2.dispose();
97 assertUndefined(
98 'goog.DisposableTest.prototype.disposeInternal should ' +
99 'have deleted the element reference',
100 d2.element);
101 }
102
103 function testDisposeAgain() {
104 d2.dispose();
105 assertUndefined(
106 'goog.DisposableTest.prototype.disposeInternal should ' +
107 'have deleted the element reference',
108 d2.element);
109 // Manually reset the element to a non-null value, and call dispose().
110 // Because the object is already marked disposed, disposeInternal won't
111 // be called again.
112 d2.element = document.getElementById('someElement');
113 d2.dispose();
114 assertNotUndefined(
115 'disposeInternal should not be called again if the ' +
116 'object has already been marked disposed',
117 d2.element);
118 }
119
120 function testDisposeWorksRecursively() {
121 new RecursiveDisposable().dispose();
122 }
123
124 function testStaticDispose() {
125 assertFalse(d1.isDisposed());
126 goog.dispose(d1);
127 assertTrue(
128 'goog.Disposable instance should have been disposed of', d1.isDisposed());
129
130 assertFalse(d2.isDisposed());
131 goog.dispose(d2);
132 assertTrue(
133 'goog.DisposableTest instance should have been disposed of',
134 d2.isDisposed());
135
136 var duck = new DisposableDuck();
137 assertNotUndefined(duck.element);
138 goog.dispose(duck);
139 assertUndefined(
140 'goog.dispose should have disposed of object that ' +
141 'implements the disposable interface',
142 duck.element);
143 }
144
145 function testStaticDisposeOnNonDisposableType() {
146 // Call goog.dispose() with various types and make sure no errors are
147 // thrown.
148 goog.dispose(true);
149 goog.dispose(false);
150 goog.dispose(null);
151 goog.dispose(undefined);
152 goog.dispose('');
153 goog.dispose([]);
154 goog.dispose({});
155
156 function A() {}
157 goog.dispose(new A());
158 }
159
160 function testMonitoringFailure() {
161 function BadDisposable(){};
162 goog.inherits(BadDisposable, goog.Disposable);
163
164 goog.Disposable.MONITORING_MODE = goog.Disposable.MonitoringMode.PERMANENT;
165
166 var badDisposable = new BadDisposable;
167 assertArrayEquals(
168 'no disposable objects registered', [],
169 goog.Disposable.getUndisposedObjects());
170 assertThrows(
171 'the base ctor should have been called',
172 goog.bind(badDisposable.dispose, badDisposable));
173 }
174
175 function testGetUndisposedObjects() {
176 goog.Disposable.MONITORING_MODE = goog.Disposable.MonitoringMode.PERMANENT;
177
178 var d1 = new DisposableTest();
179 var d2 = new DisposableTest();
180 assertSameElements(
181 'the undisposed instances', [d1, d2],
182 goog.Disposable.getUndisposedObjects());
183
184 d1.dispose();
185 assertSameElements(
186 '1 undisposed instance left', [d2],
187 goog.Disposable.getUndisposedObjects());
188
189 d1.dispose();
190 assertSameElements(
191 'second disposal of the same object is no-op', [d2],
192 goog.Disposable.getUndisposedObjects());
193
194 d2.dispose();
195 assertSameElements(
196 'all objects have been disposed of', [],
197 goog.Disposable.getUndisposedObjects());
198 }
199
200 function testClearUndisposedObjects() {
201 goog.Disposable.MONITORING_MODE = goog.Disposable.MonitoringMode.PERMANENT;
202
203 var d1 = new DisposableTest();
204 var d2 = new DisposableTest();
205 d2.dispose();
206 goog.Disposable.clearUndisposedObjects();
207 assertSameElements(
208 'no undisposed object in the registry', [],
209 goog.Disposable.getUndisposedObjects());
210
211 assertThrows(
212 'disposal after clearUndisposedObjects()', function() { d1.dispose(); });
213
214 // d2 is already disposed of, the redisposal shouldn't throw error.
215 d2.dispose();
216 }
217
218 function testRegisterDisposable() {
219 var d1 = new DisposableTest();
220 var d2 = new DisposableTest();
221
222 d1.registerDisposable(d2);
223 d1.dispose();
224
225 assertTrue('d2 should be disposed when d1 is disposed', d2.isDisposed());
226 }
227
228 function testDisposeAll() {
229 var d1 = new DisposableTest();
230 var d2 = new DisposableTest();
231
232 goog.disposeAll(d1, d2);
233
234 assertTrue('d1 should be disposed', d1.isDisposed());
235 assertTrue('d2 should be disposed', d2.isDisposed());
236 }
237
238 function testDisposeAllRecursive() {
239 var d1 = new DisposableTest();
240 var d2 = new DisposableTest();
241 var d3 = new DisposableTest();
242 var d4 = new DisposableTest();
243
244 goog.disposeAll(d1, [[d2], d3, d4]);
245
246 assertTrue('d1 should be disposed', d1.isDisposed());
247 assertTrue('d2 should be disposed', d2.isDisposed());
248 assertTrue('d3 should be disposed', d3.isDisposed());
249 assertTrue('d4 should be disposed', d4.isDisposed());
250 }
251
252 function testCreationStack() {
253 if (!new Error().stack) return;
254 goog.Disposable.MONITORING_MODE = goog.Disposable.MonitoringMode.PERMANENT;
255 var disposableStack = new DisposableTest().creationStack;
256 // Check that the name of this test function occurs in the stack trace.
257 assertNotEquals(-1, disposableStack.indexOf('testCreationStack'));
258 }
259
260 function testMonitoredWithoutCreationStack() {
261 if (!new Error().stack) return;
262 goog.Disposable.MONITORING_MODE = goog.Disposable.MonitoringMode.PERMANENT;
263 goog.Disposable.INCLUDE_STACK_ON_CREATION = false;
264 var d1 = new DisposableTest();
265
266 // Check that it is tracked, but not with a creation stack.
267 assertUndefined(d1.creationStack);
268 assertSameElements(
269 'the undisposed instance', [d1], goog.Disposable.getUndisposedObjects());
270 }
271
272 function testOnDisposeCallback() {
273 var callback = goog.testing.recordFunction();
274 d1.addOnDisposeCallback(callback);
275 assertEquals('callback called too early', 0, callback.getCallCount());
276 d1.dispose();
277 assertEquals(
278 'callback should be called once on dispose', 1, callback.getCallCount());
279 }
280
281 function testOnDisposeCallbackOrder() {
282 var invocations = [];
283 var callback = function(str) { invocations.push(str); };
284 d1.addOnDisposeCallback(goog.partial(callback, 'a'));
285 d1.addOnDisposeCallback(goog.partial(callback, 'b'));
286 goog.dispose(d1);
287 assertArrayEquals(
288 'callbacks should be called in chronological order', ['a', 'b'],
289 invocations);
290 }
291
292 function testAddOnDisposeCallbackAfterDispose() {
293 var callback = goog.testing.recordFunction();
294 var scope = {};
295 goog.dispose(d1);
296 d1.addOnDisposeCallback(callback, scope);
297 assertEquals(
298 'Callback should be immediately called if already disposed', 1,
299 callback.getCallCount());
300 assertEquals(
301 'Callback scope should be respected', scope,
302 callback.getLastCall().getThis());
303 }
304
305 function testInteractiveMonitoring() {
306 var d1 = new DisposableTest();
307 goog.Disposable.MONITORING_MODE = goog.Disposable.MonitoringMode.INTERACTIVE;
308 var d2 = new DisposableTest();
309
310 assertSameElements(
311 'only 1 undisposed instance tracked', [d2],
312 goog.Disposable.getUndisposedObjects());
313
314 // No errors should be thrown.
315 d1.dispose();
316
317 assertSameElements(
318 '1 undisposed instance left', [d2],
319 goog.Disposable.getUndisposedObjects());
320
321 d2.dispose();
322 assertSameElements(
323 'all disposed', [], goog.Disposable.getUndisposedObjects());
324 }