Fix several stack-traces tests using assertUnreachable()

test/mjsunit/stack-traces.js

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 234 matching lines @@
   try {
     nativeFunc(thrower);
     assertUnreachable(nativeFuncName);
   } catch (e) {
     assertTrue(e.stack.indexOf(nativeFuncName) >= 0, nativeFuncName);
   }
 }
 
 
 function testOmittedBuiltin(throwing, omitted) {
+  var reached = false;
   try {
     throwing();
-    assertUnreachable(omitted);
+    reached = true;
   } catch (e) {
     assertTrue(e.stack.indexOf(omitted) < 0, omitted);
+  } finally {
+    assertFalse(reached);
   }
 }
 
 
 testTrace("testArrayNative", testArrayNative, ["Array.map (native)"]);
 testTrace("testNested", testNested, ["at one", "at two", "at three"]);
 testTrace("testMethodNameInference", testMethodNameInference, ["at Foo.bar"]);
 testTrace("testImplicitConversion", testImplicitConversion, ["at Nirk.valueOf"]);
 testTrace("testEval", testEval, ["at Doo (eval at testEval"]);
 testTrace("testNestedEval", testNestedEval, ["eval at Inner (eval at Outer"]);
@@ skipping 28 matching lines @@
 
 // Omitted because QuickSort has builtins object as receiver, and is non-native
 // builtin.
 testOmittedBuiltin(function(){ [thrower, 2].sort(function (a,b) {
                                                      (b < a) - (a < b); });
                    }, "QuickSort");
 
 // Omitted because ADD from runtime.js is non-native builtin.
 testOmittedBuiltin(function(){ thrower + 2; }, "ADD");
 
+var reached = false;
 var error = new Error();
-error.toString = function() { assertUnreachable(); };
+error.toString = function() { reached = true; };
 error.stack;
+assertFalse(reached);
 
+reached = false;
 error = new Error();
-error.name = { toString: function() { assertUnreachable(); }};

[jgruber, 2016/08/03 16:20:27]

This test was completely removed since the spec actually requires calling
toString on name and message.

-error.message = { toString: function() {  assertUnreachable(); }};
+Array.prototype.push = function(x) { reached = true; };
+Array.prototype.join = function(x) { reached = true; };
 error.stack;
-
-error = new Error();
-Array.prototype.push = function(x) { assertUnreachable(); };
-Array.prototype.join = function(x) { assertUnreachable(); };
-error.stack;
+assertFalse(reached);
 
 var fired = false;
 error = new Error({ toString: function() { fired = true; } });
 assertTrue(fired);
 error.stack;
 assertTrue(fired);
 
 // Check that throwing exception in a custom stack trace formatting function
 // does not lead to recursion.
 Error.prepareStackTrace = function() { throw new Error("abc"); };
@@ skipping 100 matching lines @@
 assertTrue(err.stack.indexOf("prepareStackTrace") != -1);
 
 // Check that the callsite constructor throws.
 
 Error.prepareStackTrace = (e,s) => s;
 var constructor = new Error().stack[0].constructor;
 
 assertThrows(() => constructor.call());
 assertThrows(() => constructor.call(
     null, {}, () => undefined, {valueOf() { return 0 }}, false));