Fix a number of tests that incorrectly used assertUnreachable.

test/mjsunit/function-call.js

 // Copyright 2011 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 137 matching lines @@
 // Reduce functions.
 var reducing_functions =
     [Array.prototype.reduce,
      Array.prototype.reduceRight];
 
 // Test that all natives using the ToObject call throw the right exception.
 for (var i = 0; i < should_throw_on_null_and_undefined.length; i++) {
   // Sanity check that all functions are correct
   assertEquals(typeof(should_throw_on_null_and_undefined[i]), "function");
 
+  var exception = false;
   try {
     // We call all functions with no parameters, which means that essential
     // parameters will have the undefined value.
     // The test for whether the "this" value is null or undefined is always
     // performed before access to the other parameters, so even if the
     // undefined value is an invalid argument value, it mustn't change
     // the result of the test.
     should_throw_on_null_and_undefined[i].call(null);
-    assertUnreachable();
   } catch (e) {
+    exception = true;
     assertTrue("called_on_null_or_undefined" == e.type ||
                "null_to_object" == e.type);
   }
+  assertTrue(exception);
 
+  exception = false;
   try {
     should_throw_on_null_and_undefined[i].call(undefined);
-    assertUnreachable();
   } catch (e) {
+    exception = true;
     assertTrue("called_on_null_or_undefined" == e.type ||
                "null_to_object" == e.type);
   }
+  assertTrue(exception);
 
+  exception = false;
   try {
     should_throw_on_null_and_undefined[i].apply(null);
-    assertUnreachable();
   } catch (e) {
+    exception = true;
     assertTrue("called_on_null_or_undefined" == e.type ||
                "null_to_object" == e.type);
   }
+  assertTrue(exception);
 
+  exception = false;
   try {
     should_throw_on_null_and_undefined[i].apply(undefined);
-    assertUnreachable();
   } catch (e) {
+    exception = true;
     assertTrue("called_on_null_or_undefined" == e.type ||
                "null_to_object" == e.type);
   }
+  assertTrue(exception);
 }
 
 // Test that all natives that are non generic throw on null and undefined.
 for (var i = 0; i < non_generic.length; i++) {
   // Sanity check that all functions are correct
   assertEquals(typeof(non_generic[i]), "function");
+
+  exception = false;
   try {
     non_generic[i].call(null);
-    assertUnreachable();
   } catch (e) {
+    exception = true;
     assertTrue(e instanceof TypeError);
   }
+  assertTrue(exception);
 
+  exception = false;
   try {
     non_generic[i].call(null);
-    assertUnreachable();
   } catch (e) {
+    exception = true;
     assertTrue(e instanceof TypeError);
   }
+  assertTrue(exception);
 
+  exception = false;
   try {
     non_generic[i].apply(null);
-    assertUnreachable();
   } catch (e) {
+    exception = true;
     assertTrue(e instanceof TypeError);
   }
+  assertTrue(exception);
 
+  exception = false;
   try {
     non_generic[i].apply(null);
-    assertUnreachable();
   } catch (e) {
+    exception = true;
     assertTrue(e instanceof TypeError);
   }
+  assertTrue(exception);
 }
 
 
 // Test that we still throw when calling with thisArg null or undefined
 // through an array mapping function.
 var array = [1,2,3,4,5];
 for (var j = 0; j < mapping_functions.length; j++) {
   for (var i = 0; i < should_throw_on_null_and_undefined.length; i++) {
+    exception = false;
     try {
       mapping_functions[j].call(array,
                                 should_throw_on_null_and_undefined[i],
                                 null);
-      assertUnreachable();
     } catch (e) {
+      exception = true;
       assertTrue("called_on_null_or_undefined" == e.type ||
                  "null_to_object" == e.type);
     }
+    assertTrue(exception);
 
+    exception = false;
     try {
       mapping_functions[j].call(array,
                                 should_throw_on_null_and_undefined[i],
                                 undefined);
-      assertUnreachable();
     } catch (e) {
+      exception = true;
       assertTrue("called_on_null_or_undefined" == e.type ||
                  "null_to_object" == e.type);
     }
+    assertTrue(exception);
   }
 }
 
 for (var j = 0; j < mapping_functions.length; j++) {
   for (var i = 0; i < non_generic.length; i++) {
+    exception = false;
     try {
       mapping_functions[j].call(array,
                                 non_generic[i],
                                 null);
-      assertUnreachable();
     } catch (e) {
+      exception = true;
       assertTrue(e instanceof TypeError);
     }
+    assertTrue(exception);
 
+    exception = false;
     try {
       mapping_functions[j].call(array,
                                 non_generic[i],
                                 undefined);
-      assertUnreachable();
     } catch (e) {
+      exception = true;
       assertTrue(e instanceof TypeError);
     }
+    assertTrue(exception);
   }
 }
 
 
 // Reduce functions do a call with null as this argument.
 for (var j = 0; j < reducing_functions.length; j++) {
   for (var i = 0; i < should_throw_on_null_and_undefined.length; i++) {
+    exception = false;
     try {
       reducing_functions[j].call(array, should_throw_on_null_and_undefined[i]);
-      assertUnreachable();
     } catch (e) {
+      exception = true;
       assertTrue("called_on_null_or_undefined" == e.type ||
                  "null_to_object" == e.type);
     }
+    assertTrue(exception);
 
+    exception = false;
     try {
       reducing_functions[j].call(array, should_throw_on_null_and_undefined[i]);
-      assertUnreachable();
     } catch (e) {
+      exception = true;
       assertTrue("called_on_null_or_undefined" == e.type ||
                  "null_to_object" == e.type);
     }
+    assertTrue(exception);
   }
 }
 
 for (var j = 0; j < reducing_functions.length; j++) {
   for (var i = 0; i < non_generic.length; i++) {
+    exception = false;
     try {
       reducing_functions[j].call(array, non_generic[i]);
-      assertUnreachable();
     } catch (e) {
+      exception = true;
       assertTrue(e instanceof TypeError);
     }
+    assertTrue(exception);
 
+    exception = false;
     try {
       reducing_functions[j].call(array, non_generic[i]);
-      assertUnreachable();
     } catch (e) {
+      exception = true;
       assertTrue(e instanceof TypeError);
     }
+    assertTrue(exception);
   }
 }
 
 
 // Object.prototype.toString()
 assertEquals(Object.prototype.toString.call(null),
              '[object Null]')
 
 assertEquals(Object.prototype.toString.call(undefined),
              '[object Undefined]')