Debian Codegraph @

closure-library/closure/goog/testing/stacktrace_test.js

raw
1 // Copyright 2009 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.testing.stacktraceTest');
16 goog.setTestOnly('goog.testing.stacktraceTest');
17
18 goog.require('goog.functions');
19 goog.require('goog.string');
20 goog.require('goog.testing.ExpectedFailures');
21 goog.require('goog.testing.PropertyReplacer');
22 goog.require('goog.testing.StrictMock');
23 goog.require('goog.testing.asserts');
24 goog.require('goog.testing.jsunit');
25 goog.require('goog.testing.stacktrace');
26 goog.require('goog.testing.stacktrace.Frame');
27 goog.require('goog.userAgent');
28
29 var stubs = new goog.testing.PropertyReplacer();
30 var expectedFailures;
31 function setUpPage() {
32 expectedFailures = new goog.testing.ExpectedFailures();
33 }
34
35 function setUp() {
36 stubs.set(goog.testing.stacktrace, 'isClosureInspectorActive_', function() {
37 return false;
38 });
39 }
40
41 function tearDown() {
42 stubs.reset();
43 expectedFailures.handleTearDown();
44 }
45
46 function testParseStackFrameInV8() {
47 var frameString = ' at Error (unknown source)';
48 var frame = goog.testing.stacktrace.parseStackFrame_(frameString);
49 var expected = new goog.testing.stacktrace.Frame('', 'Error', '', '');
50 assertObjectEquals('exception name only', expected, frame);
51
52 frameString = ' at Object.assert (file:///.../asserts.js:29:10)';
53 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
54 expected = new goog.testing.stacktrace.Frame(
55 'Object', 'assert', '', 'file:///.../asserts.js:29:10');
56 assertObjectEquals('context object + function name + url', expected, frame);
57
58 frameString = ' at Object.x.y.z (/Users/bob/file.js:564:9)';
59 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
60 expected = new goog.testing.stacktrace.Frame(
61 'Object.x.y', 'z', '', '/Users/bob/file.js:564:9');
62 assertObjectEquals(
63 'nested context object + function name + url', expected, frame);
64
65 frameString = ' at http://www.example.com/jsunit.js:117:13';
66 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
67 expected = new goog.testing.stacktrace.Frame(
68 '', '', '', 'http://www.example.com/jsunit.js:117:13');
69 assertObjectEquals('url only', expected, frame);
70
71 frameString = ' at [object Object].exec [as execute] (file:///foo)';
72 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
73 expected = new goog.testing.stacktrace.Frame(
74 '[object Object]', 'exec', 'execute', 'file:///foo');
75 assertObjectEquals('function alias', expected, frame);
76
77 frameString = ' at new Class (file:///foo)';
78 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
79 expected =
80 new goog.testing.stacktrace.Frame('', 'new Class', '', 'file:///foo');
81 assertObjectEquals('constructor call', expected, frame);
82
83 frameString = ' at new <anonymous> (file:///foo)';
84 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
85 expected = new goog.testing.stacktrace.Frame(
86 '', 'new <anonymous>', '', 'file:///foo');
87 assertObjectEquals('anonymous constructor call', expected, frame);
88
89 frameString = ' at Array.forEach (native)';
90 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
91 expected = new goog.testing.stacktrace.Frame('Array', 'forEach', '', '');
92 assertObjectEquals('native function call', expected, frame);
93
94 frameString = ' at foo (eval at file://bar)';
95 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
96 expected =
97 new goog.testing.stacktrace.Frame('', 'foo', '', 'eval at file://bar');
98 assertObjectEquals('eval', expected, frame);
99
100 frameString = ' at foo.bar (closure/goog/foo.js:11:99)';
101 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
102 expected = new goog.testing.stacktrace.Frame(
103 'foo', 'bar', '', 'closure/goog/foo.js:11:99');
104 assertObjectEquals('Path without schema', expected, frame);
105
106 // In the Chrome console, execute: console.log(eval('Error().stack')).
107 frameString =
108 ' at eval (eval at <anonymous> (unknown source), <anonymous>:1:1)';
109 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
110 expected = new goog.testing.stacktrace.Frame(
111 '', 'eval', '', 'eval at <anonymous> (unknown source), <anonymous>:1:1');
112 assertObjectEquals('nested eval', expected, frame);
113 }
114
115 function testParseStackFrameInOpera() {
116 var frameString = '@';
117 var frame = goog.testing.stacktrace.parseStackFrame_(frameString);
118 var expected = new goog.testing.stacktrace.Frame('', '', '', '');
119 assertObjectEquals('empty frame', expected, frame);
120
121 frameString = '@javascript:console.log(Error().stack):1';
122 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
123 expected = new goog.testing.stacktrace.Frame(
124 '', '', '', 'javascript:console.log(Error().stack):1');
125 assertObjectEquals('javascript path only', expected, frame);
126
127 frameString = '@file:///foo:42';
128 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
129 expected = new goog.testing.stacktrace.Frame('', '', '', 'file:///foo:42');
130 assertObjectEquals('path only', expected, frame);
131
132 // (function go() { throw new Error() })()
133 // var c = go; c()
134 frameString = 'go([arguments not available])@';
135 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
136 expected = new goog.testing.stacktrace.Frame('', 'go', '', '');
137 assertObjectEquals('name and empty path', expected, frame);
138
139 frameString = 'go([arguments not available])@file:///foo:42';
140 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
141 expected = new goog.testing.stacktrace.Frame('', 'go', '', 'file:///foo:42');
142 assertObjectEquals('name and path', expected, frame);
143
144 // (function() { throw new Error() })()
145 frameString =
146 '<anonymous function>([arguments not available])@file:///foo:42';
147 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
148 expected = new goog.testing.stacktrace.Frame('', '', '', 'file:///foo:42');
149 assertObjectEquals('anonymous function', expected, frame);
150
151 // var b = {foo: function() { throw new Error() }}
152 frameString = '<anonymous function: foo>()@file:///foo:42';
153 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
154 expected = new goog.testing.stacktrace.Frame('', 'foo', '', 'file:///foo:42');
155 assertObjectEquals('object literal function', expected, frame);
156
157 // var c = {}; c.foo = function() { throw new Error() }
158 frameString = '<anonymous function: c.foo>()@file:///foo:42';
159 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
160 expected =
161 new goog.testing.stacktrace.Frame('c', 'foo', '', 'file:///foo:42');
162 assertObjectEquals('named object literal function', expected, frame);
163
164 frameString = '<anonymous function: Foo.prototype.bar>()@';
165 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
166 expected = new goog.testing.stacktrace.Frame('Foo.prototype', 'bar', '', '');
167 assertObjectEquals('prototype function', expected, frame);
168
169 frameString = '<anonymous function: goog.Foo.prototype.bar>()@';
170 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
171 expected =
172 new goog.testing.stacktrace.Frame('goog.Foo.prototype', 'bar', '', '');
173 assertObjectEquals('namespaced prototype function', expected, frame);
174 }
175
176 // All test strings are parsed with the conventional and long
177 // frame algorithms.
178 function testParseStackFrameInFirefox() {
179 var frameString = 'Error("Assertion failed")@:0';
180 var frame = goog.testing.stacktrace.parseStackFrame_(frameString);
181 var expected = new goog.testing.stacktrace.Frame('', 'Error', '', '');
182 assertObjectEquals('function name + arguments', expected, frame);
183
184 frameString = '()@file:///foo:42';
185 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
186 expected = new goog.testing.stacktrace.Frame('', '', '', 'file:///foo:42');
187 assertObjectEquals('anonymous function', expected, frame);
188
189 frameString = '@javascript:alert(0)';
190 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
191 expected =
192 new goog.testing.stacktrace.Frame('', '', '', 'javascript:alert(0)');
193 assertObjectEquals('anonymous function', expected, frame);
194 }
195
196 // All test strings are parsed with the conventional and long
197 // frame algorithms.
198 function testParseStackFrameInFirefoxWithQualifiedName() {
199 var frameString = 'ns.method@http://some.thing/a.js:1:2';
200 var frame = goog.testing.stacktrace.parseStackFrame_(frameString);
201 var expected = new goog.testing.stacktrace.Frame(
202 '', 'ns.method', '', 'http://some.thing/a.js:1:2');
203 assertObjectEquals('anonymous function', expected, frame);
204 }
205
206 function testCanonicalizeFrame() {
207 var frame = new goog.testing.stacktrace.Frame(
208 '<window>', 'foo', 'bar', 'http://x?a=1&b=2:1');
209 assertEquals(
210 'canonical stack frame, everything is escaped', '&lt;window&gt;.foo ' +
211 '[as bar] at http://x?a=1&amp;b=2:1',
212 frame.toCanonicalString());
213 }
214
215 function testDeobfuscateFunctionName() {
216 goog.testing.stacktrace.setDeobfuscateFunctionName(function(name) {
217 return name.replace(/\$/g, '.');
218 });
219
220 var frame = new goog.testing.stacktrace.Frame('', 'a$b$c', 'd$e', '');
221 assertEquals(
222 'deobfuscated function name', 'a.b.c [as d.e]',
223 frame.toCanonicalString());
224 }
225
226 function testFramesToString() {
227 var normalFrame = new goog.testing.stacktrace.Frame('', 'foo', '', '');
228 var anonFrame = new goog.testing.stacktrace.Frame('', '', '', '');
229 var frames = [normalFrame, anonFrame, null, anonFrame];
230 var stack = goog.testing.stacktrace.framesToString_(frames);
231 assertEquals('framesToString', '> foo\n> anonymous\n> (unknown)\n', stack);
232 }
233
234 function testFollowCallChain() {
235 var func = function(var_args) {
236 return goog.testing.stacktrace.followCallChain_();
237 };
238
239 // Created a fake type with a toString method.
240 function LocalType(){};
241 LocalType.prototype.toString = function() { return 'sg'; };
242
243 // Create a mock with no expectations.
244 var mock = new goog.testing.StrictMock(LocalType);
245
246 mock.$replay();
247
248 var frames = func(
249 undefined, null, false, 0, '', {}, goog.nullFunction, mock,
250 new LocalType);
251
252 // Opera before version 10 doesn't support the caller attribute. In that
253 // browser followCallChain_() returns empty stack trace.
254 expectedFailures.expectFailureFor(
255 goog.userAgent.OPERA && !goog.userAgent.isVersionOrHigher('10'));
256 try {
257 assertTrue('The stack trace consists of >=2 frames', frames.length >= 2);
258 } catch (e) {
259 expectedFailures.handleException(e);
260 }
261
262 if (frames.length >= 2) {
263 assertEquals('innermost function is anonymous', '', frames[0].getName());
264 // There are white space differences how browsers convert functions to
265 // strings.
266 assertEquals(
267 'test function name', 'testFollowCallChain', frames[1].getName());
268 }
269
270 mock.$verify();
271 }
272
273 // Create a stack trace string with one modest record and one long record,
274 // Verify that all frames are parsed. The length of the long arg is set
275 // to blow Firefox 3x's stack if put through a RegExp.
276 function testParsingLongStackTrace() {
277 var longArg =
278 goog.string.buildString('(', goog.string.repeat('x', 1000000), ')');
279 var stackTrace = goog.string.buildString(
280 'shortFrame()@:0\n', 'longFrame', longArg,
281 '@http://google.com/somescript:0\n');
282 var frames = goog.testing.stacktrace.parse_(stackTrace);
283 assertEquals('number of returned frames', 2, frames.length);
284 var expected = new goog.testing.stacktrace.Frame('', 'shortFrame', '', '');
285 assertObjectEquals('short frame', expected, frames[0]);
286
287 assertNull('exception no frame', frames[1]);
288 }
289
290 function testParseStackFrameInIE10() {
291 var frameString = ' at foo (http://bar:4000/bar.js:150:3)';
292 var frame = goog.testing.stacktrace.parseStackFrame_(frameString);
293 var expected = new goog.testing.stacktrace.Frame(
294 '', 'foo', '', 'http://bar:4000/bar.js:150:3');
295 assertObjectEquals('name and path', expected, frame);
296
297 frameString = ' at Anonymous function (http://bar:4000/bar.js:150:3)';
298 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
299 expected = new goog.testing.stacktrace.Frame(
300 '', 'Anonymous function', '', 'http://bar:4000/bar.js:150:3');
301 assertObjectEquals('Anonymous function', expected, frame);
302
303 frameString = ' at Global code (http://bar:4000/bar.js:150:3)';
304 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
305 expected = new goog.testing.stacktrace.Frame(
306 '', 'Global code', '', 'http://bar:4000/bar.js:150:3');
307 assertObjectEquals('Global code', expected, frame);
308
309 frameString = ' at foo (eval code:150:3)';
310 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
311 expected =
312 new goog.testing.stacktrace.Frame('', 'foo', '', 'eval code:150:3');
313 assertObjectEquals('eval code', expected, frame);
314
315 frameString = ' at eval code (eval code:150:3)';
316 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
317 expected =
318 new goog.testing.stacktrace.Frame('', 'eval code', '', 'eval code:150:3');
319 assertObjectEquals('nested eval', expected, frame);
320 }
321
322 function testParseStackFrameInIE11() {
323 var frameString = ' at a.b.c (Unknown script code:150:3)';
324 var frame = goog.testing.stacktrace.parseStackFrame_(frameString);
325 var expected = new goog.testing.stacktrace.Frame(
326 '', 'a.b.c', '', 'Unknown script code:150:3');
327 assertObjectEquals('name and path', expected, frame);
328 }
329
330 function testParseStackFrameInEdge() {
331 frameString = ' at a.b.c (http://host.com:80/some/file.js:101:2)';
332 frame = goog.testing.stacktrace.parseStackFrame_(frameString);
333 expected = new goog.testing.stacktrace.Frame(
334 '', 'a.b.c', '', 'http://host.com:80/some/file.js:101:2');
335 assertObjectEquals(expected, frame);
336 }
337
338 // Verifies that retrieving the stack trace works when the 'stack' field of an
339 // exception contains an array of CallSites instead of a string. This is the
340 // case when running in a lightweight V8 runtime (for instance, in gjstests),
341 // as opposed to a browser environment.
342 function testGetStackFrameWithV8CallSites() {
343 // A function to create V8 CallSites. Note that CallSite is an extern and thus
344 // cannot be mocked with closure mocks.
345 function createCallSite(functionName, fileName, lineNumber, colNumber) {
346 return {
347 getFunctionName: goog.functions.constant(functionName),
348 getFileName: goog.functions.constant(fileName),
349 getLineNumber: goog.functions.constant(lineNumber),
350 getColumnNumber: goog.functions.constant(colNumber)
351 };
352 }
353
354 // Mock the goog.testing.stacktrace.getStack_ function, which normally
355 // triggers an exception for the purpose of reading and returning its stack
356 // trace. Here, pretend that V8 provided an array of CallSites instead of the
357 // string that browsers provide.
358 stubs.set(goog.testing.stacktrace, 'getNativeStack_', function() {
359 return [
360 createCallSite('fn1', 'file1', 1, 2),
361 createCallSite('fn2', 'file2', 3, 4), createCallSite('fn3', 'file3', 5, 6)
362 ];
363 });
364
365 // Retrieve the stacktrace. This should translate the array of CallSites into
366 // a single multi-line string.
367 var stackTrace = goog.testing.stacktrace.get();
368
369 // Make sure the stack trace was translated correctly.
370 var frames = stackTrace.split('\n');
371 assertEquals(frames[0], '> fn1 at file1:1:2');
372 assertEquals(frames[1], '> fn2 at file2:3:4');
373 assertEquals(frames[2], '> fn3 at file3:5:6');
374 }