deps/v8/test/mjsunit/stack-traces.js

   1 // Copyright 2009 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 function testMethodNameInference() {
  29   function Foo() { }
  30   Foo.prototype.bar = function () { FAIL; };
  31   (new Foo).bar();
  32 }
  33
  34 function testNested() {
  35   function one() {
  36     function two() {
  37       function three() {
  38         FAIL;
  39       }
  40       three();
  41     }
  42     two();
  43   }
  44   one();
  45 }
  46
  47 function testArrayNative() {
  48   [1, 2, 3].map(function () { FAIL; });
  49 }
  50
  51 function testImplicitConversion() {
  52   function Nirk() { }
  53   Nirk.prototype.valueOf = function () { FAIL; };
  54   return 1 + (new Nirk);
  55 }
  56
  57 function testEval() {
  58   eval("function Doo() { FAIL; }; Doo();");
  59 }
  60
  61 function testNestedEval() {
  62   var x = "FAIL";
  63   eval("function Outer() { eval('function Inner() { eval(x); }'); Inner(); }; Outer();");
  64 }
  65
  66 function testEvalWithSourceURL() {
  67   eval("function Doo() { FAIL; }; Doo();\n//# sourceURL=res://name");
  68 }
  69
  70 function testNestedEvalWithSourceURL() {
  71   var x = "FAIL";
  72   var innerEval = 'function Inner() { eval(x); }\n//@ sourceURL=res://inner-eval';
  73   eval("function Outer() { eval(innerEval); Inner(); }; Outer();\n//# sourceURL=res://outer-eval");
  74 }
  75
  76 function testValue() {
  77   Number.prototype.causeError = function () { FAIL; };
  78   (1).causeError();
  79 }
  80
  81 function testConstructor() {
  82   function Plonk() { FAIL; }
  83   new Plonk();
  84 }
  85
  86 function testRenamedMethod() {
  87   function a$b$c$d() { return FAIL; }
  88   function Wookie() { }
  89   Wookie.prototype.d = a$b$c$d;
  90   (new Wookie).d();
  91 }
  92
  93 function testAnonymousMethod() {
  94   (function () { FAIL }).call([1, 2, 3]);
  95 }
  96
  97 function CustomError(message, stripPoint) {
  98   this.message = message;
  99   Error.captureStackTrace(this, stripPoint);
 100 }
 101
 102 CustomError.prototype.toString = function () {
 103   return "CustomError: " + this.message;
 104 };
 105
 106 function testDefaultCustomError() {
 107   throw new CustomError("hep-hey", undefined);
 108 }
 109
 110 function testStrippedCustomError() {
 111   throw new CustomError("hep-hey", CustomError);
 112 }
 113
 114 MyObj = function() { FAIL; }
 115
 116 MyObjCreator = function() {}
 117
 118 MyObjCreator.prototype.Create = function() {
 119   return new MyObj();
 120 }
 121
 122 function testClassNames() {
 123   (new MyObjCreator).Create();
 124 }
 125
 126 // Utility function for testing that the expected strings occur
 127 // in the stack trace produced when running the given function.
 128 function testTrace(name, fun, expected, unexpected) {
 129   var threw = false;
 130   try {
 131     fun();
 132   } catch (e) {
 133     for (var i = 0; i < expected.length; i++) {
 134       assertTrue(e.stack.indexOf(expected[i]) != -1,
 135                  name + " doesn't contain expected[" + i + "] stack = " + e.stack);
 136     }
 137     if (unexpected) {
 138       for (var i = 0; i < unexpected.length; i++) {
 139         assertEquals(e.stack.indexOf(unexpected[i]), -1,
 140                      name + " contains unexpected[" + i + "]");
 141       }
 142     }
 143     threw = true;
 144   }
 145   assertTrue(threw, name + " didn't throw");
 146 }
 147
 148 // Test that the error constructor is not shown in the trace
 149 function testCallerCensorship() {
 150   var threw = false;
 151   try {
 152     FAIL;
 153   } catch (e) {
 154     assertEquals(-1, e.stack.indexOf('at new ReferenceError'),
 155                  "CallerCensorship contained new ReferenceError");
 156     threw = true;
 157   }
 158   assertTrue(threw, "CallerCensorship didn't throw");
 159 }
 160
 161 // Test that the explicit constructor call is shown in the trace
 162 function testUnintendedCallerCensorship() {
 163   var threw = false;
 164   try {
 165     new ReferenceError({
 166       toString: function () {
 167         FAIL;
 168       }
 169     });
 170   } catch (e) {
 171     assertTrue(e.stack.indexOf('at new ReferenceError') != -1,
 172                "UnintendedCallerCensorship didn't contain new ReferenceError");
 173     threw = true;
 174   }
 175   assertTrue(threw, "UnintendedCallerCensorship didn't throw");
 176 }
 177
 178 // If an error occurs while the stack trace is being formatted it should
 179 // be handled gracefully.
 180 function testErrorsDuringFormatting() {
 181   function Nasty() { }
 182   Nasty.prototype.foo = function () { throw new RangeError(); };
 183   var n = new Nasty();
 184   n.__defineGetter__('constructor', function () { CONS_FAIL; });
 185   var threw = false;
 186   try {
 187     n.foo();
 188   } catch (e) {
 189     threw = true;
 190     assertTrue(e.stack.indexOf('<error: ReferenceError') != -1,
 191                "ErrorsDuringFormatting didn't contain error: ReferenceError");
 192   }
 193   assertTrue(threw, "ErrorsDuringFormatting didn't throw");
 194   threw = false;
 195   // Now we can't even format the message saying that we couldn't format
 196   // the stack frame.  Put that in your pipe and smoke it!
 197   ReferenceError.prototype.toString = function () { NESTED_FAIL; };
 198   try {
 199     n.foo();
 200   } catch (e) {
 201     threw = true;
 202     assertTrue(e.stack.indexOf('<error>') != -1,
 203                "ErrorsDuringFormatting didn't contain <error>");
 204   }
 205   assertTrue(threw, "ErrorsDuringFormatting didnt' throw (2)");
 206 }
 207
 208
 209 // Poisonous object that throws a reference error if attempted converted to
 210 // a primitive values.
 211 var thrower = { valueOf: function() { FAIL; },
 212                 toString: function() { FAIL; } };
 213
 214 // Tests that a native constructor function is included in the
 215 // stack trace.
 216 function testTraceNativeConstructor(nativeFunc) {
 217   var nativeFuncName = nativeFunc.name;
 218   try {
 219     new nativeFunc(thrower);
 220     assertUnreachable(nativeFuncName);
 221   } catch (e) {
 222     assertTrue(e.stack.indexOf(nativeFuncName) >= 0, nativeFuncName);
 223   }
 224 }
 225
 226 // Tests that a native conversion function is included in the
 227 // stack trace.
 228 function testTraceNativeConversion(nativeFunc) {
 229   var nativeFuncName = nativeFunc.name;
 230   try {
 231     nativeFunc(thrower);
 232     assertUnreachable(nativeFuncName);
 233   } catch (e) {
 234     assertTrue(e.stack.indexOf(nativeFuncName) >= 0, nativeFuncName);
 235   }
 236 }
 237
 238
 239 function testOmittedBuiltin(throwing, omitted) {
 240   try {
 241     throwing();
 242     assertUnreachable(omitted);
 243   } catch (e) {
 244     assertTrue(e.stack.indexOf(omitted) < 0, omitted);
 245   }
 246 }
 247
 248
 249 testTrace("testArrayNative", testArrayNative, ["Array.map (native)"]);
 250 testTrace("testNested", testNested, ["at one", "at two", "at three"]);
 251 testTrace("testMethodNameInference", testMethodNameInference, ["at Foo.bar"]);
 252 testTrace("testImplicitConversion", testImplicitConversion, ["at Nirk.valueOf"]);
 253 testTrace("testEval", testEval, ["at Doo (eval at testEval"]);
 254 testTrace("testNestedEval", testNestedEval, ["eval at Inner (eval at Outer"]);
 255 testTrace("testEvalWithSourceURL", testEvalWithSourceURL,
 256     [ "at Doo (res://name:1:18)" ]);
 257 testTrace("testNestedEvalWithSourceURL", testNestedEvalWithSourceURL,
 258     [" at Inner (res://inner-eval:1:20)",
 259      " at Outer (res://outer-eval:1:37)"]);
 260 testTrace("testValue", testValue, ["at Number.causeError"]);
 261 testTrace("testConstructor", testConstructor, ["new Plonk"]);
 262 testTrace("testRenamedMethod", testRenamedMethod, ["Wookie.a$b$c$d [as d]"]);
 263 testTrace("testAnonymousMethod", testAnonymousMethod, ["Array.<anonymous>"]);
 264 testTrace("testDefaultCustomError", testDefaultCustomError,
 265     ["hep-hey", "new CustomError"],
 266     ["collectStackTrace"]);
 267 testTrace("testStrippedCustomError", testStrippedCustomError, ["hep-hey"],
 268     ["new CustomError", "collectStackTrace"]);
 269 testTrace("testClassNames", testClassNames,
 270           ["new MyObj", "MyObjCreator.Create"], ["as Create"]);
 271 testCallerCensorship();
 272 testUnintendedCallerCensorship();
 273 testErrorsDuringFormatting();
 274
 275 testTraceNativeConversion(String);  // Does ToString on argument.
 276 testTraceNativeConversion(Number);  // Does ToNumber on argument.
 277 testTraceNativeConversion(RegExp);  // Does ToString on argument.
 278
 279 testTraceNativeConstructor(String);  // Does ToString on argument.
 280 testTraceNativeConstructor(Number);  // Does ToNumber on argument.
 281 testTraceNativeConstructor(RegExp);  // Does ToString on argument.
 282 testTraceNativeConstructor(Date);    // Does ToNumber on argument.
 283
 284 // Omitted because QuickSort has builtins object as receiver, and is non-native
 285 // builtin.
 286 testOmittedBuiltin(function(){ [thrower, 2].sort(function (a,b) {
 287                                                      (b < a) - (a < b); });
 288                    }, "QuickSort");
 289
 290 // Omitted because ADD from runtime.js is non-native builtin.
 291 testOmittedBuiltin(function(){ thrower + 2; }, "ADD");
 292
 293 var error = new Error();
 294 error.toString = function() { assertUnreachable(); };
 295 error.stack;
 296
 297 error = new Error();
 298 error.name = { toString: function() { assertUnreachable(); }};
 299 error.message = { toString: function() {  assertUnreachable(); }};
 300 error.stack;
 301
 302 error = new Error();
 303 Array.prototype.push = function(x) { assertUnreachable(); };
 304 Array.prototype.join = function(x) { assertUnreachable(); };
 305 error.stack;
 306
 307 var fired = false;
 308 error = new Error({ toString: function() { fired = true; } });
 309 assertTrue(fired);
 310 error.stack;
 311 assertTrue(fired);
 312
 313 // Check that throwing exception in a custom stack trace formatting function
 314 // does not lead to recursion.
 315 Error.prepareStackTrace = function() { throw new Error("abc"); };
 316 var message;
 317 try {
 318   try {
 319     throw new Error();
 320   } catch (e) {
 321     e.stack;
 322   }
 323 } catch (e) {
 324   message = e.message;
 325 }
 326
 327 assertEquals("abc", message);
 328
 329 // Test that modifying Error.prepareStackTrace by itself works.
 330 Error.prepareStackTrace = function() { Error.prepareStackTrace = "custom"; };
 331 new Error().stack;
 332
 333 assertEquals("custom", Error.prepareStackTrace);
 334
 335 // Check that the formatted stack trace can be set to undefined.
 336 error = new Error();
 337 error.stack = undefined;
 338 assertEquals(undefined, error.stack);
 339
 340 // Check that the stack trace accessors are not forcibly set.
 341 var my_error = {};
 342 Object.freeze(my_error);
 343 assertThrows(function() { Error.captureStackTrace(my_error); });
 344
 345 my_error = {};
 346 Object.preventExtensions(my_error);
 347 assertThrows(function() { Error.captureStackTrace(my_error); });
 348
 349 var fake_error = {};
 350 my_error = new Error();
 351 var stolen_getter = Object.getOwnPropertyDescriptor(my_error, 'stack').get;
 352 Object.defineProperty(fake_error, 'stack', { get: stolen_getter });
 353 assertEquals(undefined, fake_error.stack);