Extracted the predicate version of toThrowError into its own matcher

This simplifies the signature of each matcher to something that jsdoc
can actually handle.

[Finishes #20622765]

spec/core/matchers/toThrowErrorSpec.js

@@ -7,7 +7,7 @@ describe("toThrowError", function() {
     }).toThrowError(/Actual is not a Function/);
   });
 
-  it("throws an error when the expected is not an Error, string, RegExp, or function", function() {
+  it("throws an error when the expected is not an Error, string, or RegExp", function() {
     var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new Error("foo");
@@ -15,7 +15,7 @@ describe("toThrowError", function() {
 
     expect(function() {
       matcher.compare(fn, 1);
-    }).toThrowError(/Expected is not an Error, string, RegExp, or Function./);
+    }).toThrowError(/Expected is not an Error, string, or RegExp./);
   });
 
   it("throws an error when the expected error type is not an Error", function() {
@@ -312,32 +312,4 @@ describe("toThrowError", function() {
     expect(result.pass).toBe(false);
     expect(result.message()).toEqual("Expected function to throw TypeError with a message matching /bar/, but it threw TypeError with message 'foo'.");
   });
-
-  it("passes if the argument is a function that returns true when called with the error", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
-    predicate = function(e) { return e.message === "nope" },
-      fn = function() {
-        throw new TypeError("nope");
-      },
-      result;
-
-    result = matcher.compare(fn, predicate);
-
-    expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw an exception matching a predicate.");
-  });
-
-  it("fails if the argument is a function that returns false when called with the error", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
-    predicate = function(e) { return e.message === "oh no" },
-      fn = function() {
-        throw new TypeError("nope");
-      },
-      result;
-
-    result = matcher.compare(fn, predicate);
-
-    expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw an exception matching a predicate, but it threw TypeError with message 'nope'.");
-  });
 });

spec/core/matchers/toThrowMatchingSpec.js

@@ -0,0 +1,73 @@
+describe("toThrowMatching", function() {
+  it("throws an error when the actual is not a function", function() {
+    var matcher = jasmineUnderTest.matchers.toThrowMatching();
+
+    expect(function() {
+      matcher.compare({}, function() { return true; });
+    }).toThrowError(/Actual is not a Function/);
+  });
+
+  it("throws an error when the expected is not a function", function() {
+    var matcher = jasmineUnderTest.matchers.toThrowMatching(),
+      fn = function() {
+        throw new Error("foo");
+      };
+
+    expect(function() {
+      matcher.compare(fn, 1);
+    }).toThrowError(/Predicate is not a Function/);
+  });
+
+  it("fails if actual does not throw at all", function() {
+    var matcher = jasmineUnderTest.matchers.toThrowMatching(),
+      fn = function() {
+        return true;
+      },
+      result;
+
+    result = matcher.compare(fn, function() { return true; });
+
+    expect(result.pass).toBe(false);
+    expect(result.message).toEqual("Expected function to throw an exception.");
+  });
+
+  it("fails with the correct message if thrown is a falsy value", function() {
+    var matcher = jasmineUnderTest.matchers.toThrowMatching(),
+      fn = function() {
+        throw undefined;
+      },
+      result;
+
+    result = matcher.compare(fn, function() { return false; });
+    expect(result.pass).toBe(false);
+    expect(result.message()).toEqual("Expected function to throw an exception matching a predicate, but it threw undefined.");
+  });
+
+  it("passes if the argument is a function that returns true when called with the error", function() {
+    var matcher = jasmineUnderTest.matchers.toThrowMatching(),
+    predicate = function(e) { return e.message === "nope" },
+      fn = function() {
+        throw new TypeError("nope");
+      },
+      result;
+
+    result = matcher.compare(fn, predicate);
+
+    expect(result.pass).toBe(true);
+    expect(result.message).toEqual("Expected function not to throw an exception matching a predicate.");
+  });
+
+  it("fails if the argument is a function that returns false when called with the error", function() {
+    var matcher = jasmineUnderTest.matchers.toThrowMatching(),
+    predicate = function(e) { return e.message === "oh no" },
+      fn = function() {
+        throw new TypeError("nope");
+      },
+      result;
+
+    result = matcher.compare(fn, predicate);
+
+    expect(result.pass).toBe(false);
+    expect(result.message()).toEqual("Expected function to throw an exception matching a predicate, but it threw TypeError with message 'nope'.");
+  });
+});