openlayers/mapbox-gl/closure-library/closure/goog/testing/stacktrace_test.js

// Copyright 2009 The Closure Library Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS-IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

goog.provide('goog.testing.stacktraceTest');
goog.setTestOnly('goog.testing.stacktraceTest');

goog.require('goog.functions');
goog.require('goog.string');
goog.require('goog.testing.ExpectedFailures');
goog.require('goog.testing.PropertyReplacer');
goog.require('goog.testing.StrictMock');
goog.require('goog.testing.asserts');
goog.require('goog.testing.jsunit');
goog.require('goog.testing.stacktrace');
goog.require('goog.testing.stacktrace.Frame');
goog.require('goog.userAgent');

var stubs = new goog.testing.PropertyReplacer();
var expectedFailures;
function setUpPage() {
  expectedFailures = new goog.testing.ExpectedFailures();
}

function setUp() {
  stubs.set(goog.testing.stacktrace, 'isClosureInspectorActive_', function() {
    return false;
  });
}

function tearDown() {
  stubs.reset();
  expectedFailures.handleTearDown();
}

function testParseStackFrameInV8() {
  var frameString = '    at Error (unknown source)';
  var frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  var expected = new goog.testing.stacktrace.Frame('', 'Error', '', '', '');
  assertObjectEquals('exception name only', expected, frame);

  frameString = '    at Object.assert (file:///.../asserts.js:29:10)';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('Object', 'assert', '', '',
      'file:///.../asserts.js:29:10');
  assertObjectEquals('context object + function name + url', expected, frame);

  frameString = '    at Object.x.y.z (/Users/bob/file.js:564:9)';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('Object.x.y', 'z', '', '',
      '/Users/bob/file.js:564:9');
  assertObjectEquals('nested context object + function name + url',
      expected, frame);

  frameString = '    at http://www.example.com/jsunit.js:117:13';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('', '', '', '',
      'http://www.example.com/jsunit.js:117:13');
  assertObjectEquals('url only', expected, frame);

  frameString = '    at [object Object].exec [as execute] (file:///foo)';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('[object Object]', 'exec',
      'execute', '', 'file:///foo');
  assertObjectEquals('function alias', expected, frame);

  frameString = '    at new Class (file:///foo)';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('', 'new Class', '', '',
      'file:///foo');
  assertObjectEquals('constructor call', expected, frame);

  frameString = '    at new <anonymous> (file:///foo)';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('', 'new <anonymous>', '', '',
      'file:///foo');
  assertObjectEquals('anonymous constructor call', expected, frame);

  frameString = '    at Array.forEach (native)';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('Array', 'forEach', '', '', '');
  assertObjectEquals('native function call', expected, frame);

  frameString = '    at foo (eval at file://bar)';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('', 'foo', '', '',
      'eval at file://bar');
  assertObjectEquals('eval', expected, frame);

  frameString = '    at foo.bar (closure/goog/foo.js:11:99)';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('foo', 'bar', '', '',
      'closure/goog/foo.js:11:99');
  assertObjectEquals('Path without schema', expected, frame);

  // In the Chrome console, execute: console.log(eval('Error().stack')).
  frameString =
      '    at eval (eval at <anonymous> (unknown source), <anonymous>:1:1)';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('', 'eval', '', '',
      'eval at <anonymous> (unknown source), <anonymous>:1:1');
  assertObjectEquals('nested eval', expected, frame);
}

function testParseStackFrameInOpera() {
  var frameString = '@';
  var frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  var expected = new goog.testing.stacktrace.Frame('', '', '', '', '');
  assertObjectEquals('empty frame', expected, frame);

  frameString = '@javascript:console.log(Error().stack):1';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('', '', '', '',
      'javascript:console.log(Error().stack):1');
  assertObjectEquals('javascript path only', expected, frame);

  frameString = '@file:///foo:42';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('', '', '', '',
      'file:///foo:42');
  assertObjectEquals('path only', expected, frame);

  // (function go() { throw Error() })()
  // var c = go; c()
  frameString = 'go([arguments not available])@';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('', 'go', '',
      '([arguments not available])', '');
  assertObjectEquals('name and empty path', expected, frame);

  frameString = 'go([arguments not available])@file:///foo:42';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('', 'go', '',
      '([arguments not available])', 'file:///foo:42');
  assertObjectEquals('name and path', expected, frame);

  // (function() { throw Error() })()
  frameString =
      '<anonymous function>([arguments not available])@file:///foo:42';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('', '', '',
      '([arguments not available])', 'file:///foo:42');
  assertObjectEquals('anonymous function', expected, frame);

  // var b = {foo: function() { throw Error() }}
  frameString = '<anonymous function: foo>()@file:///foo:42';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame(
      '', 'foo', '', '()', 'file:///foo:42');
  assertObjectEquals('object literal function', expected, frame);

  // var c = {}; c.foo = function() { throw Error() }
  frameString = '<anonymous function: c.foo>()@file:///foo:42';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame(
      'c', 'foo', '', '()', 'file:///foo:42');
  assertObjectEquals('named object literal function', expected, frame);

  frameString = '<anonymous function: Foo.prototype.bar>()@';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame(
      'Foo.prototype', 'bar', '', '()', '');
  assertObjectEquals('prototype function', expected, frame);

  frameString = '<anonymous function: goog.Foo.prototype.bar>()@';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame(
      'goog.Foo.prototype', 'bar', '', '()', '');
  assertObjectEquals('namespaced prototype function', expected, frame);
}

// All test strings are parsed with the conventional and long
// frame algorithms.
function testParseStackFrameInFirefox() {
  var frameString = 'Error("Assertion failed")@:0';
  var frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  var expected = new goog.testing.stacktrace.Frame('', 'Error', '',
      '("Assertion failed")', '');
  assertObjectEquals('function name + arguments', expected, frame);

  frame = goog.testing.stacktrace.parseLongFirefoxFrame_(frameString);
  assertObjectEquals('function name + arguments', expected, frame);

  frameString = '()@file:///foo:42';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('', '', '', '()',
      'file:///foo:42');
  assertObjectEquals('anonymous function', expected, frame);

  frame = goog.testing.stacktrace.parseLongFirefoxFrame_(frameString);
  assertObjectEquals('anonymous function', expected, frame);

  frameString = '@javascript:alert(0)';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('', '', '', '',
      'javascript:alert(0)');
  assertObjectEquals('anonymous function', expected, frame);

  frame = goog.testing.stacktrace.parseLongFirefoxFrame_(frameString);
  assertObjectEquals('anonymous function', expected, frame);
}

function testCanonicalizeFrame() {
  var frame = new goog.testing.stacktrace.Frame('<window>', 'foo', 'bar',
      '("<a>\'&amp;")', 'http://x?a=1&b=2:1');
  assertEquals('canonical stack frame, everything is escaped',
      '&lt;window&gt;.foo(&quot;&lt;a&gt;\'&amp;amp;&quot;) ' +
      '[as bar] at http://x?a=1&amp;b=2:1', frame.toCanonicalString());
}

function testDeobfuscateFunctionName() {
  goog.testing.stacktrace.setDeobfuscateFunctionName(function(name) {
    return name.replace(/\$/g, '.');
  });

  var frame = new goog.testing.stacktrace.Frame('', 'a$b$c', 'd$e', '', '');
  assertEquals('deobfuscated function name', 'a.b.c [as d.e]',
      frame.toCanonicalString());
}

function testFramesToString() {
  var normalFrame = new goog.testing.stacktrace.Frame('', 'foo', '', '', '');
  var anonFrame = new goog.testing.stacktrace.Frame('', '', '', '', '');
  var frames = [normalFrame, anonFrame, null, anonFrame];
  var stack = goog.testing.stacktrace.framesToString_(frames);
  assertEquals('framesToString', '> foo\n> anonymous\n> (unknown)\n', stack);
}

function testFollowCallChain() {
  var func = function(var_args) {
    return goog.testing.stacktrace.followCallChain_();
  };

  // Created a fake type with a toString method.
  function LocalType() {};
  LocalType.prototype.toString = function() {
    return 'sg';
  };

  // Create a mock with no expectations.
  var mock = new goog.testing.StrictMock(LocalType);

  mock.$replay();

  var frames = func(undefined, null, false, 0, '', {}, goog.nullFunction,
      mock, new LocalType);

  // Opera before version 10 doesn't support the caller attribute. In that
  // browser followCallChain_() returns empty stack trace.
  expectedFailures.expectFailureFor(goog.userAgent.OPERA &&
      !goog.userAgent.isVersionOrHigher('10'));
  try {
    assertTrue('The stack trace consists of >=2 frames', frames.length >= 2);
  } catch (e) {
    expectedFailures.handleException(e);
  }

  if (frames.length >= 2) {
    assertEquals('innermost function is anonymous', '', frames[0].getName());
    // There are white space differences how browsers convert functions to
    // strings.
    var expected = '(undefined,null,false,0,"",[objectObject],function(){},' +
        'goog.testing.Mock,sg)';
    assertEquals('arguments of the innermost function (ignoring whitespaces)',
        expected, frames[0].args_.replace(/\s/g, ''));
    assertEquals('test function name', 'testFollowCallChain',
        frames[1].getName());
  }

  mock.$verify();
}

// Create a stack trace string with one modest record and one long record,
// Verify that all frames are parsed. The length of the long arg is set
// to blow Firefox 3x's stack if put through a RegExp.
function testParsingLongStackTrace() {
  var longArg = goog.string.buildString(
      '(', goog.string.repeat('x', 1000000), ')');
  var stackTrace = goog.string.buildString(
      'shortFrame()@:0\n',
      'longFrame',
      longArg,
      '@http://google.com/somescript:0\n');
  var frames = goog.testing.stacktrace.parse_(stackTrace);
  assertEquals('number of returned frames', 2, frames.length);
  var expected = new goog.testing.stacktrace.Frame(
      '', 'shortFrame', '', '()', '');
  assertObjectEquals('short frame', expected, frames[0]);

  expected = new goog.testing.stacktrace.Frame(
      '', 'longFrame', '', longArg, 'http://google.com/somescript:0');
  assertObjectEquals('exception name only', expected, frames[1]);
}

function testParseStackFrameInIE10() {
  var frameString = '   at foo (http://bar:4000/bar.js:150:3)';
  var frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  var expected = new goog.testing.stacktrace.Frame('', 'foo', '', '',
      'http://bar:4000/bar.js:150:3');
  assertObjectEquals('name and path', expected, frame);

  frameString = '   at Anonymous function (http://bar:4000/bar.js:150:3)';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('', 'Anonymous function', '', '',
      'http://bar:4000/bar.js:150:3');
  assertObjectEquals('Anonymous function', expected, frame);

  frameString = '   at Global code (http://bar:4000/bar.js:150:3)';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('', 'Global code', '', '',
      'http://bar:4000/bar.js:150:3');
  assertObjectEquals('Global code', expected, frame);

  frameString = '   at foo (eval code:150:3)';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('', 'foo', '', '',
      'eval code:150:3');
  assertObjectEquals('eval code', expected, frame);

  frameString = '   at eval code (eval code:150:3)';
  frame = goog.testing.stacktrace.parseStackFrame_(frameString);
  expected = new goog.testing.stacktrace.Frame('', 'eval code', '', '',
      'eval code:150:3');
  assertObjectEquals('nested eval', expected, frame);
}

// Verifies that retrieving the stack trace works when the 'stack' field of an
// exception contains an array of CallSites instead of a string. This is the
// case when running in a lightweight V8 runtime (for instance, in gjstests),
// as opposed to a browser environment.
function testGetStackFrameWithV8CallSites() {
  // A function to create V8 CallSites. Note that CallSite is an extern and thus
  // cannot be mocked with closure mocks.
  function createCallSite(functionName, fileName, lineNumber, colNumber) {
    return {
      getFunctionName: goog.functions.constant(functionName),
      getFileName: goog.functions.constant(fileName),
      getLineNumber: goog.functions.constant(lineNumber),
      getColumnNumber: goog.functions.constant(colNumber)
    };
  }

  // Mock the goog.testing.stacktrace.getStack_ function, which normally
  // triggers an exception for the purpose of reading and returning its stack
  // trace. Here, pretend that V8 provided an array of CallSites instead of the
  // string that browsers provide.
  stubs.set(goog.testing.stacktrace, 'getNativeStack_', function() {
    return [
      createCallSite('fn1', 'file1', 1, 2),
      createCallSite('fn2', 'file2', 3, 4),
      createCallSite('fn3', 'file3', 5, 6)
    ];
  });

  // Retrieve the stacktrace. This should translate the array of CallSites into
  // a single multi-line string.
  var stackTrace = goog.testing.stacktrace.get();

  // Make sure the stack trace was translated correctly.
  var frames = stackTrace.split('\n');
  assertEquals(frames[0], '> fn1 at file1:1:2');
  assertEquals(frames[1], '> fn2 at file2:3:4');
  assertEquals(frames[2], '> fn3 at file3:5:6');
}