diff --git a/lib/chai-as-promised.js b/lib/chai-as-promised.js
index c6808e0..219a504 100644
--- a/lib/chai-as-promised.js
+++ b/lib/chai-as-promised.js
@@ -1,26 +1,24 @@
-(function () {
+(function (factory) {
     "use strict";
-
-    // Module systems magic dance.
-
     /* istanbul ignore else */
     if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {
         // NodeJS
-        module.exports = chaiAsPromised;
+        module.exports = factory(require("check-error"));
     } else if (typeof define === "function" && define.amd) {
         // AMD
-        define(function () {
-            return chaiAsPromised;
-        });
+        define(["check-error"], factory);
     } else {
         /*global self: false */
 
         // Other environment (usually <script> tag): plug in to global chai instance directly.
+        var chaiAsPromised = factory(self.checkError);
         chai.use(chaiAsPromised);
 
         // Expose as a property of the global object so that consumers can configure the `transferPromiseness` property.
         self.chaiAsPromised = chaiAsPromised;
     }
+}(function (checkError) {
+    "use strict";
 
     chaiAsPromised.transferPromiseness = function (assertion, promise) {
         assertion.then = promise.then.bind(promise);
@@ -34,6 +32,13 @@
         var Assertion = chai.Assertion;
         var assert = chai.assert;
 
+        // If we are using a version of Chai that has checkError on it,
+        // we want to use that version to be consistent. Otherwise, we use
+        // what was passed to the factory.
+        if (utils.checkError) {
+            checkError = utils.checkError;
+        }
+
         function isLegacyJQueryPromise(thenable) {
             // jQuery promises are Promises/A+-compatible since 3.0.0. jQuery 3.0.0 is also the first version
             // to define the catch method.
@@ -92,6 +97,10 @@
             return typeof assertion.then === "function" ? assertion : assertion._obj;
         }
 
+        function getReasonName(reason) {
+            return (reason instanceof Error) ? reason.toString() : checkError.getConstructorName(reason);
+        }
+
         // Grab these first, before we modify `Assertion.prototype`.
 
         var propertyNames = Object.getOwnPropertyNames(Assertion.prototype);
@@ -105,7 +114,6 @@
             var that = this;
             var derivedPromise = getBasePromise(that).then(
                 function (value) {
-                    that._obj = value;
                     assertIfNegated(that,
                                     "expected promise not to be fulfilled but it was fulfilled with #{act}",
                                     { actual: value });
@@ -114,7 +122,8 @@
                 function (reason) {
                     assertIfNotNegated(that,
                                        "expected promise to be fulfilled but it was rejected with #{act}",
-                                       { actual: reason });
+                                       { actual: getReasonName(reason) });
+                    return reason;
                 }
             );
 
@@ -125,7 +134,6 @@
             var that = this;
             var derivedPromise = getBasePromise(that).then(
                 function (value) {
-                    that._obj = value;
                     assertIfNotNegated(that,
                                        "expected promise to be rejected but it was fulfilled with #{act}",
                                        { actual: value });
@@ -134,7 +142,7 @@
                 function (reason) {
                     assertIfNegated(that,
                                     "expected promise not to be rejected but it was rejected with #{act}",
-                                    { actual: reason });
+                                    { actual: getReasonName(reason) });
 
                     // Return the reason, transforming this into a fulfillment, to allow further assertions, e.g.
                     // `promise.should.be.rejected.and.eventually.equal("reason")`.
@@ -145,21 +153,38 @@
             chaiAsPromised.transferPromiseness(that, derivedPromise);
         });
 
-        method("rejectedWith", function (Constructor, message) {
-            var desiredReason = null;
-            var constructorName = null;
-
-            if (Constructor instanceof RegExp || typeof Constructor === "string") {
-                message = Constructor;
-                Constructor = null;
-            } else if (Constructor && Constructor instanceof Error) {
-                desiredReason = Constructor;
-                Constructor = null;
-                message = null;
-            } else if (typeof Constructor === "function") {
-                constructorName = (new Constructor()).name;
+        method("rejectedWith", function (errorLike, errMsgMatcher, message) {
+            var errorLikeName = null;
+            var negate = utils.flag(this, "negate") || false;
+
+            // rejectedWith with that is called without arguments is
+            // the same as a plain ".rejected" use.
+            if (errorLike === undefined && errMsgMatcher === undefined &&
+                message === undefined) {
+                /* jshint expr: true */
+                this.rejected;
+                return;
+            }
+
+            if (message !== undefined) {
+                utils.flag(this, "message", message);
+            }
+
+            if (errorLike instanceof RegExp || typeof errorLike === "string") {
+                errMsgMatcher = errorLike;
+                errorLike = null;
+            } else if (errorLike && errorLike instanceof Error) {
+                errorLikeName = errorLike.toString();
+            } else if (typeof errorLike === "function") {
+                errorLikeName = checkError.getConstructorName(errorLike);
             } else {
-                Constructor = null;
+                errorLike = null;
+            }
+            var everyArgIsDefined = Boolean(errorLike && errMsgMatcher);
+
+            var matcherRelation = "including";
+            if (errMsgMatcher instanceof RegExp) {
+                matcherRelation = "matching";
             }
 
             var that = this;
@@ -168,61 +193,60 @@
                     var assertionMessage = null;
                     var expected = null;
 
-                    if (Constructor) {
-                        assertionMessage = "expected promise to be rejected with #{exp} but it was fulfilled with " +
-                                           "#{act}";
-                        expected = constructorName;
-                    } else if (message) {
-                        var verb = message instanceof RegExp ? "matching" : "including";
-                        assertionMessage = "expected promise to be rejected with an error " + verb + " #{exp} but it " +
-                                           "was fulfilled with #{act}";
-                        expected = message;
-                    } else if (desiredReason) {
+                    if (errorLike) {
                         assertionMessage = "expected promise to be rejected with #{exp} but it was fulfilled with " +
                                            "#{act}";
-                        expected = desiredReason;
+                        expected = errorLikeName;
+                    } else if (errMsgMatcher) {
+                        assertionMessage = "expected promise to be rejected with an error " + matcherRelation +
+                            " #{exp} but it was fulfilled with #{act}";
+                        expected = errMsgMatcher;
                     }
 
-                    that._obj = value;
-
                     assertIfNotNegated(that, assertionMessage, { expected: expected, actual: value });
+                    return value;
                 },
                 function (reason) {
-                    if (Constructor) {
-                        that.assert(reason instanceof Constructor,
-                                    "expected promise to be rejected with #{exp} but it was rejected with #{act}",
-                                    "expected promise not to be rejected with #{exp} but it was rejected with #{act}",
-                                    constructorName,
-                                    reason);
+                    var errorLikeCompatible = errorLike && (errorLike instanceof Error ?
+                                                            checkError.compatibleInstance(reason, errorLike) :
+                                                            checkError.compatibleConstructor(reason, errorLike));
+
+                    var errMsgMatcherCompatible = errMsgMatcher && checkError.compatibleMessage(reason, errMsgMatcher);
+
+                    var reasonName = getReasonName(reason);
+
+                    if (negate && everyArgIsDefined) {
+                        if (errorLikeCompatible && errMsgMatcherCompatible) {
+                            that.assert(true,
+                                        null,
+                                        "expected promise not to be rejected with #{exp} but it was rejected " +
+                                        "with #{act}",
+                                        errorLikeName,
+                                        reasonName);
+                        }
                     }
-
-                    var reasonMessage = utils.type(reason) === "object" && "message" in reason ?
-                                            reason.message :
-                                            "" + reason;
-                    if (message && reasonMessage !== null && reasonMessage !== undefined) {
-                        if (message instanceof RegExp) {
-                            that.assert(message.test(reasonMessage),
-                                        "expected promise to be rejected with an error matching #{exp} but got #{act}",
-                                        "expected promise not to be rejected with an error matching #{exp}",
-                                        message,
-                                        reasonMessage);
+                    else {
+                        if (errorLike) {
+                            that.assert(errorLikeCompatible,
+                                        "expected promise to be rejected with #{exp} but it was rejected with #{act}",
+                                        "expected promise not to be rejected with #{exp} but it was rejected " +
+                                        "with #{act}",
+                                        errorLikeName,
+                                        reasonName);
                         }
-                        if (typeof message === "string") {
-                            that.assert(reasonMessage.indexOf(message) !== -1,
-                                        "expected promise to be rejected with an error including #{exp} but got #{act}",
-                                        "expected promise not to be rejected with an error including #{exp}",
-                                        message,
-                                        reasonMessage);
+
+                        if (errMsgMatcher) {
+                            that.assert(errMsgMatcherCompatible,
+                                        "expected promise to be rejected with an error " + matcherRelation +
+                                        " #{exp} but got #{act}",
+                                        "expected promise not to be rejected with an error " + matcherRelation +
+                                        " #{exp}",
+                                        errMsgMatcher,
+                                        checkError.getMessage(reason));
                         }
                     }
 
-                    if (desiredReason) {
-                        that.assert(reason === desiredReason,
-                                    "expected promise to be rejected with #{exp} but it was rejected with #{act}",
-                                    "expected promise not to be rejected with #{exp}",
-                                    desiredReason,
-                                    reason);
-                    }
+                    return reason;
                 }
             );
 
@@ -326,14 +350,9 @@
             return (new Assertion(promise, message)).to.be.fulfilled;
         };
 
-        assert.isRejected = function (promise, toTestAgainst, message) {
-            if (typeof toTestAgainst === "string") {
-                message = toTestAgainst;
-                toTestAgainst = undefined;
-            }
-
+        assert.isRejected = function (promise, errorLike, errMsgMatcher, message) {
             var assertion = (new Assertion(promise, message));
-            return toTestAgainst !== undefined ? assertion.to.be.rejectedWith(toTestAgainst) : assertion.to.be.rejected;
+            return assertion.to.be.rejectedWith(errorLike, errMsgMatcher, message);
         };
 
         assert.becomes = function (promise, value, message) {
@@ -372,4 +391,6 @@
             };
         });
     }
-}());
+
+    return chaiAsPromised;
+}));
diff --git a/package.json b/package.json
index b342f6b..c1d37cd 100644
--- a/package.json
+++ b/package.json
@@ -30,14 +30,15 @@
     "cover": "istanbul cover node_modules/mocha/bin/_mocha && opener ./coverage/lcov-report/lib/chai-as-promised.js.html"
   },
   "peerDependencies": {
-    "chai": ">= 2.1.2 < 4"
+    "chai": ">= 2.1.2 < 4",
+    "check-error": "^1.0.2"
   },
   "devDependencies": {
     "chai": "^3.0.0",
     "coffee-script": "1.10.0",
-    "istanbul": "0.4.1",
     "ecstatic": "^1.3.1",
     "glob": "^6.0.1",
+    "istanbul": "0.4.1",
     "jshint": "^2.8.0",
     "mocha": "^2.3.4",
     "opener": "^1.4.1",
diff --git a/test/assert-promise-specific.coffee b/test/assert-promise-specific.coffee
index 3bef638..2d94b8d 100644
--- a/test/assert-promise-specific.coffee
+++ b/test/assert-promise-specific.coffee
@@ -3,6 +3,7 @@
 describe "Assert interface:", =>
     promise = null
     error = new Error("boo")
+    custom = "No. I am your father."
 
     describe "when the promise is fulfilled", =>
         beforeEach =>
@@ -19,6 +20,11 @@ describe "Assert interface:", =>
                 op: => assert.becomes(promise, baz: "quux")
                 message: "to deeply equal { baz: 'quux' }"
 
+        describe ".becomes(promise, incorrectValue, custom)", =>
+            shouldFail
+                op: => assert.becomes(promise, baz: "quux", custom)
+                message: custom
+
         describe ".doesNotBecome(promise, correctValue)", =>
             shouldFail
                 op: => assert.doesNotBecome(promise, foo: "bar")
@@ -26,6 +32,11 @@ describe "Assert interface:", =>
         describe ".doesNotBecome(promise, incorrectValue)", =>
             shouldPass => assert.doesNotBecome(promise, baz: "quux")
 
+        describe ".doesNotBecome(promise, correctValue, custom)", =>
+            shouldFail
+                op: => assert.doesNotBecome(promise, foo: "bar", custom)
+                message: custom
+
         describe ".isRejected(promise)", =>
             shouldFail
                 op: => assert.isRejected(promise)
@@ -38,7 +49,7 @@ describe "Assert interface:", =>
             shouldFail
                 op: => assert.isRejected(promise, /regexp/)
                 message: "to be rejected"
-        describe ".isRejected(promise, /regexp/)", =>
+        describe ".isRejected(promise, TypeError, /regexp/)", =>
             shouldFail
                 op: => assert.isRejected(promise, TypeError, /regexp/)
                 message: "to be rejected"
@@ -46,17 +57,32 @@ describe "Assert interface:", =>
             shouldFail
                 op: => assert.isRejected(promise, error)
                 message: "to be rejected"
+        # Chai never interprets the 3rd parameter to assert.throws as
+        # a custom error message. This is what we are checking here.
+        describe ".isRejected(promise, /quux/, custom)", =>
+            shouldFail
+                op: => assert.isRejected(promise, /quux/, custom)
+                notMessage: custom
+
 
     describe "when the promise is rejected", =>
         beforeEach =>
             promise = rejectedPromise(error)
             return undefined
 
-        describe ".isFulfilled", =>
+        describe ".isFulfilled(promise)", =>
             shouldFail
                 op: => assert.isFulfilled(promise)
                 message: "to be fulfilled"
 
+        describe ".isFulfilled(promise, custom)", =>
+            shouldFail
+                op: => assert.isFulfilled(promise, custom)
+                message: custom
+
+        describe ".isRejected(promise)", =>
+            shouldPass => assert.isRejected(promise)
+
         describe ".isRejected(promise, theError)", =>
             shouldPass => assert.isRejected(promise, error)
 
@@ -65,14 +91,42 @@ describe "Assert interface:", =>
                 op: => assert.isRejected(promise, new Error)
                 message: "to be rejected with"
 
+        # Chai never interprets the 3rd parameter to assert.throws as
+        # a custom error message. This is what we are checking here.
+        describe ".isRejected(promise, differentError, custom)", =>
+            shouldFail
+                op: => assert.isRejected(promise, new Error, custom)
+                notMessage: custom
+
         describe "with an Error having message 'foo bar'", =>
             beforeEach =>
                 promise = rejectedPromise(new Error("foo bar"))
                 return undefined
 
+            describe ".isRejected(promise, 'bar')", =>
+                shouldPass => assert.isRejected(promise, "bar")
+
+            describe ".isRejected(promise, 'bar', custom)", =>
+                shouldPass => assert.isRejected(promise, "bar", custom)
+
             describe ".isRejected(promise, /bar/)", =>
                 shouldPass => assert.isRejected(promise, /bar/)
 
+            describe ".isRejected(promise, /bar/, custom)", =>
+                shouldPass => assert.isRejected(promise, /bar/, custom)
+
+            describe ".isRejected(promise, 'quux')", =>
+                shouldFail
+                    op: => assert.isRejected(promise, "quux")
+                    message: "to be rejected with"
+
+            # Chai 3.5.0 never interprets the 3rd parameter to assert.throws as
+            # a custom error message. This is what we are checking here.
+            describe ".isRejected(promise, 'quux', custom)", =>
+                shouldFail
+                    op: => assert.isRejected(promise, "quux", custom)
+                    notMessage: custom
+
             describe ".isRejected(promise, /quux/)", =>
                 shouldFail
                     op: => assert.isRejected(promise, /quux/)
@@ -85,40 +139,71 @@ describe "Assert interface:", =>
 
             describe ".isRejected(promise, RangeError)", =>
                 shouldPass => assert.isRejected(promise, RangeError)
+
             describe ".isRejected(promise, TypeError)", =>
                 shouldFail
                     op: => assert.isRejected(promise, TypeError)
                     message: "to be rejected"
 
-    describe "Assertion messages", =>
-        message = "No. I am your father."
+        describe "with a RangeError having a message 'foo bar'", =>
+            beforeEach =>
+                promise = rejectedPromise(new RangeError("foo bar"))
+                return undefined
 
-        describe "should be passed through for .isFulfilled(promise, message)", =>
-            shouldFail
-                op: => assert.isFulfilled(rejectedPromise(), message)
-                message: message
+            describe ".isRejected(promise, RangeError, 'foo')", =>
+                shouldPass => assert.isRejected(promise, RangeError, "foo")
 
-        describe "should be passed through for .isRejected(promise, message)", =>
-            shouldFail
-                op: => assert.isRejected(fulfilledPromise(), message)
-                message: message
+            describe ".isRejected(promise, RangeError, /bar/)", =>
+                shouldPass => assert.isRejected(promise, RangeError, /bar/)
 
-        describe "should be passed through for .isRejected(promise, TypeError, message)", =>
-            shouldFail
-                op: => assert.isRejected(fulfilledPromise(), TypeError, message)
-                message: message
+            describe ".isRejected(promise, RangeError, 'quux')", =>
+                shouldFail
+                    op: => assert.isRejected(promise, RangeError, "quux")
+                    message: "to be rejected with an error including 'quux' but got 'foo bar'"
 
-        describe "should be passed through for .isRejected(promise, /regexp/, message)", =>
-            shouldFail
-                op: => assert.isRejected(fulfilledPromise(), /regexp/, message)
-                message: message
+            describe ".isRejected(promise, RangeError, /quux/)", =>
+                shouldFail
+                    op: => assert.isRejected(promise, RangeError, /quux/)
+                    message: "to be rejected with an error matching /quux/ but got 'foo bar'"
 
-        describe "should be passed through for .becomes(promise, incorrectValue, message)", =>
-            shouldFail
-                op: => assert.becomes(fulfilledPromise(baz: "quux"), foo: "bar", message)
-                message: message
+            describe ".isRejected(promise, TypeError, 'foo')", =>
+                shouldFail
+                    op: => assert.isRejected(promise, TypeError, 'foo')
+                    message: "to be rejected with 'TypeError' but it was rejected with 'RangeError: foo bar'"
+            describe ".isRejected(promise, TypeError, /bar/)", =>
+                shouldFail
+                    op: => assert.isRejected(promise, TypeError, /bar/)
+                    message: "to be rejected with 'TypeError' but it was rejected with 'RangeError: foo bar'"
 
-        describe "should be passed through for .doesNotBecome(promise, incorrectValue, message)", =>
-            shouldFail
-                op: => assert.doesNotBecome(fulfilledPromise(foo: "bar"), foo: "bar", message)
-                message: message
+            describe ".isRejected(promise, TypeError, 'quux')", =>
+                shouldFail
+                    op: => assert.isRejected(promise, TypeError, 'quux')
+                    message: "to be rejected with 'TypeError' but it was rejected with 'RangeError: foo bar'"
+            describe ".isRejected(promise, TypeError, /quux/)", =>
+                shouldFail
+                    op: => assert.isRejected(promise, TypeError, /quux/)
+                    message: "to be rejected with 'TypeError' but it was rejected with 'RangeError: foo bar'"
+
+            describe ".isRejected(promise, RangeError, 'foo', custom)", =>
+                shouldPass => assert.isRejected(promise, RangeError, "foo", custom)
+
+            describe ".isRejected(promise, RangeError, /bar/, custom)", =>
+                shouldPass => assert.isRejected(promise, RangeError, /bar/, custom)
+
+            describe ".isRejected(promise, RangeError, 'quux', custom)", =>
+                shouldFail
+                    op: => assert.isRejected(promise, RangeError, "quux", custom)
+                    message: custom
+
+            describe ".isRejected(promise, RangeError, /quux/, custom)", =>
+                shouldFail
+                    op: => assert.isRejected(promise, RangeError, /quux/, custom)
+                    message: custom
+
+            describe ".isRejected(promise, RangeError, undefined, custom)", =>
+                shouldPass => assert.isRejected(promise, RangeError, undefined, custom)
+
+            describe ".isRejected(promise, TypeError, undefined, custom)", =>
+                shouldFail
+                op: => assert.isRejected(promise, TypeError, undefined, custom)
+                message: custom
diff --git a/test/browser/template.html b/test/browser/template.html
index e1362c7..881afcb 100644
--- a/test/browser/template.html
+++ b/test/browser/template.html
@@ -8,6 +8,7 @@
 
     <script src="http://coffeescript.org/extras/coffee-script.js"></script>
     <script src="../../node_modules/mocha/mocha.js"></script>
+    <script src="../../node_modules/check-error/check-error.js"></script>
     <script src="../../node_modules/chai/chai.js"></script>
     <script src="../../lib/chai-as-promised.js"></script>
 
diff --git a/test/should-promise-specific.coffee b/test/should-promise-specific.coffee
index 957a83f..39fdd1b 100644
--- a/test/should-promise-specific.coffee
+++ b/test/should-promise-specific.coffee
@@ -3,6 +3,8 @@
 describe "Promise-specific extensions:", =>
     promise = null
     error = new Error("boo")
+    error.myProp = ["myProp value"]
+    custom = "No. I am your father."
 
     assertingDoneFactory = (done) =>
         (result) =>
@@ -15,45 +17,70 @@ describe "Promise-specific extensions:", =>
 
     describe "when the promise is fulfilled", =>
         beforeEach =>
-            promise = fulfilledPromise()
+            promise = fulfilledPromise(42)
             return undefined
 
         describe ".fulfilled", =>
             shouldPass => promise.should.be.fulfilled
+
+        describe ".fulfilled passes the fulfilled value", =>
+            shouldPass => promise.should.be.fulfilled.then (passedValue) =>
+                passedValue.should.equal(42)
+
+        describe ".fulfilled allows chaining", =>
+            shouldPass => promise.should.be.fulfilled.and.eventually.equal(42)
+
         describe ".not.fulfilled", =>
             shouldFail
                 op: => promise.should.not.be.fulfilled
-                message: "not to be fulfilled but it was fulfilled with undefined"
+                message: "not to be fulfilled but it was fulfilled with 42"
 
         describe ".rejected", =>
             shouldFail
               op: => promise.should.be.rejected
-              message: "to be rejected but it was fulfilled with undefined"
+              message: "to be rejected but it was fulfilled with 42"
+
+        describe ".not.rejected passes the fulfilled value", =>
+            shouldPass => promise.should.not.be.rejected.then (passedValue) =>
+                passedValue.should.equal(42)
+
+        # .not inverts all following assertions so the following test is
+        # equivalent to promise.should.eventually.not.equal(31)
+        describe ".not.rejected allows chaining", =>
+            shouldPass => promise.should.not.be.rejected.and.eventually.equal(31)
+
         describe ".rejectedWith(TypeError)", =>
             shouldFail
                 op: => promise.should.be.rejectedWith(TypeError)
-                message: "to be rejected with 'TypeError' but it was fulfilled with undefined"
+                message: "to be rejected with 'TypeError' but it was fulfilled with 42"
+        describe ".not.rejectedWith(TypeError) passes the fulfilled value", =>
+            shouldPass => promise.should.not.be.rejectedWith(TypeError).then (passedValue) =>
+                passedValue.should.equal(42)
+
+        describe ".not.rejectedWith(TypeError) allows chaining", =>
+            shouldPass => promise.should.not.be.rejectedWith(TypeError).and.eventually.equal(31)
+
         describe ".rejectedWith('message substring')", =>
             shouldFail
                 op: => promise.should.be.rejectedWith("message substring")
                 message: "to be rejected with an error including 'message substring' but it was fulfilled with " +
-                         "undefined"
+                         "42"
         describe ".rejectedWith(/regexp/)", =>
             shouldFail
                 op: => promise.should.be.rejectedWith(/regexp/)
-                message: "to be rejected with an error matching /regexp/ but it was fulfilled with undefined"
+                message: "to be rejected with an error matching /regexp/ but it was fulfilled with 42"
         describe ".rejectedWith(TypeError, 'message substring')", =>
             shouldFail
                 op: => promise.should.be.rejectedWith(TypeError, "message substring")
-                message: "to be rejected with 'TypeError' but it was fulfilled with undefined"
+                message: "to be rejected with 'TypeError' but it was fulfilled with 42"
         describe ".rejectedWith(TypeError, /regexp/)", =>
             shouldFail
                 op: => promise.should.be.rejectedWith(TypeError, /regexp/)
-                message: "to be rejected with 'TypeError' but it was fulfilled with undefined"
+                message: "to be rejected with 'TypeError' but it was fulfilled with 42"
         describe ".rejectedWith(errorInstance)", =>
             shouldFail
                 op: => promise.should.be.rejectedWith(error)
-                message: "to be rejected with [Error: boo] but it was fulfilled with undefined"
+                message: "to be rejected with 'Error: boo' but it was fulfilled with 42"
 
         describe ".not.rejected", =>
             shouldPass => promise.should.not.be.rejected
@@ -82,27 +109,67 @@ describe "Promise-specific extensions:", =>
         describe ".fulfilled", =>
             shouldFail
                 op: => promise.should.be.fulfilled
-                message: "to be fulfilled but it was rejected with [Error: boo]"
+                message: "to be fulfilled but it was rejected with 'Error: boo'"
+
         describe ".not.fulfilled", =>
             shouldPass => promise.should.not.be.fulfilled
 
+        describe ".not.fulfilled should allow chaining", =>
+            shouldPass => promise.should.not.be.fulfilled.and.eventually.have.property("nonexistent")
+
+        describe ".not.fulfilled should pass the rejection reason", =>
+            shouldPass => promise.should.not.be.fulfilled.then (passedError) =>
+                passedError.should.equal(error)
+
         describe ".rejected", =>
             shouldPass => promise.should.be.rejected
 
+        describe ".not.rejected", =>
+            shouldFail
+                op: => promise.should.not.be.rejected
+                message: "not to be rejected but it was rejected with 'Error: boo'"
+        describe ".rejected should allow chaining", =>
+            shouldPass => promise.should.be.rejected.and.eventually.have.property("myProp")
+
+        describe ".rejected passes the rejection reason", =>
+            shouldPass => promise.should.be.rejected.then (passedError) =>
+                passedError.should.equal(error)
+
         describe ".rejectedWith(theError)", =>
             shouldPass => promise.should.be.rejectedWith(error)
+
         describe ".not.rejectedWith(theError)", =>
             shouldFail
                 op: => promise.should.not.be.rejectedWith(error)
-                message: "not to be rejected with [Error: boo]"
+                message: "not to be rejected with 'Error: boo'"
+
+        describe ".rejectedWith(theError) should allow chaining", =>
+            shouldPass => promise.should.be.rejectedWith(error).and.eventually.have.property("myProp")
+
+        describe ".rejectedWith(theError) passes the rejection reason", =>
+            shouldPass => promise.should.be.rejectedWith(error).then (passedError) =>
+                passedError.should.equal(error)
 
         describe ".rejectedWith(differentError)", =>
             shouldFail
                 op: => promise.should.be.rejectedWith(new Error)
-                message: "to be rejected with [Error] but it was rejected with [Error: boo]"
+                message: "to be rejected with 'Error' but it was rejected with 'Error: boo'"
+
         describe ".not.rejectedWith(differentError)", =>
             shouldPass => promise.should.not.be.rejectedWith(new Error)
 
+        # Chai 3.5.0 never interprets the 2nd paramter to
+        # expect(fn).to.throw(a, b) as a custom error message. This is
+        # what we are testing here.
+        describe ".rejectedWith(differentError, custom)", =>
+            shouldFail
+                op: => promise.should.be.rejectedWith(new Error, custom)
+                message: "to be rejected with 'Error' but it was rejected with 'Error: boo'"
+                notMessage: custom
+
+        describe ".not.rejectedWith(differentError, custom)", =>
+            shouldPass => promise.should.not.be.rejectedWith(new Error, custom)
+
         describe "with an Error having message 'foo bar'", =>
             beforeEach =>
                 promise = rejectedPromise(new Error("foo bar"))
@@ -110,31 +177,56 @@ describe "Promise-specific extensions:", =>
 
             describe ".rejectedWith('foo')", =>
                 shouldPass => promise.should.be.rejectedWith("foo")
+
+            describe ".not.rejectedWith('foo')", =>
+                shouldFail
+                    op: => promise.should.not.be.rejectedWith("foo")
+                    message: "not to be rejected with an error including 'foo'"
+
             describe ".rejectedWith(/bar/)", =>
                 shouldPass => promise.should.be.rejectedWith(/bar/)
 
+            describe ".not.rejectedWith(/bar/)", =>
+                shouldFail
+                    op: => promise.should.not.be.rejectedWith(/bar/)
+                    message: "not to be rejected with an error matching /bar/"
+
             describe ".rejectedWith('quux')", =>
                 shouldFail
                     op: => promise.should.be.rejectedWith("quux")
-                    message: "to be rejected with an error including 'quux' but got 'Error: foo bar'"
+                    message: "to be rejected with an error including 'quux' but got 'foo bar'"
+
+            describe ".not.rejectedWith('quux')", =>
+                shouldPass => promise.should.be.not.rejectedWith("quux")
+
             describe ".rejectedWith(/quux/)", =>
                 shouldFail
                     op: => promise.should.be.rejectedWith(/quux/)
-                    message: "to be rejected with an error matching /quux/ but got 'Error: foo bar'"
+                    message: "to be rejected with an error matching /quux/ but got 'foo bar'"
 
-            describe ".not.rejectedWith('foo')", =>
+            describe ".not.rejectedWith(/quux/)", =>
+                shouldPass => promise.should.not.be.rejectedWith(/quux/)
+
+            # Chai 3.5.0 never interprets the 2nd paramter to
+            # expect(fn).to.throw(a, b) as a custom error
+            # message. This is what we are testing here.
+            describe ".rejectedWith('foo', custom)", =>
+                shouldPass => promise.should.be.rejectedWith("foo", custom)
+
+            describe ".not.rejectedWith('foo', custom)", =>
                 shouldFail
-                    op: => promise.should.not.be.rejectedWith("foo")
+                    op: => promise.should.not.be.rejectedWith("foo", custom)
                     message: "not to be rejected with an error including 'foo'"
-            describe ".not.rejectedWith(/bar/)", =>
+                    notMessage: custom
+
+            describe ".rejectedWith(/bar/, custom)", =>
+                shouldPass => promise.should.be.rejectedWith(/bar/, custom)
+
+            describe ".not.rejectedWith(/bar/, custom)", =>
                 shouldFail
                     op: => promise.should.not.be.rejectedWith(/bar/)
                     message: "not to be rejected with an error matching /bar/"
-
-            describe ".not.rejectedWith('quux')", =>
-                shouldPass => promise.should.not.be.rejectedWith("quux")
-            describe ".not.rejectedWith(/quux/)", =>
-                shouldPass => promise.should.not.be.rejectedWith(/quux/)
+                    notMessage: custom
 
         describe "with a RangeError", =>
             beforeEach =>
@@ -143,15 +235,23 @@ describe "Promise-specific extensions:", =>
 
             describe ".rejectedWith(RangeError)", =>
                 shouldPass => promise.should.be.rejectedWith(RangeError)
+
+            describe ".not.rejectedWith(RangeError)", =>
+                shouldFail
+                    op: => promise.should.not.be.rejectedWith(RangeError)
+                    message: "not to be rejected with 'RangeError' but it was rejected with 'RangeError'"
+
             describe ".rejectedWith(TypeError)", =>
                 shouldFail
                     op: => promise.should.be.rejectedWith(TypeError)
-                    message: "to be rejected with 'TypeError' but it was rejected with [RangeError]"
+                    message: "to be rejected with 'TypeError' but it was rejected with 'RangeError'"
 
-            describe ".not.rejectedWith(RangeError)", =>
+            # Case for issue #64.
+            describe ".rejectedWith(Array)", =>
                 shouldFail
-                    op: => promise.should.not.be.rejectedWith(RangeError)
-                    message: "not to be rejected with 'RangeError' but it was rejected with [RangeError]"
+                    op: => promise.should.be.rejectedWith(Array)
+                    message: "to be rejected with 'Array' but it was rejected with 'RangeError'"
+
             describe ".not.rejectedWith(TypeError)", =>
                 shouldPass => promise.should.not.be.rejectedWith(TypeError)
 
@@ -162,67 +262,115 @@ describe "Promise-specific extensions:", =>
 
             describe ".rejectedWith(RangeError, 'foo')", =>
                 shouldPass => promise.should.be.rejectedWith(RangeError, "foo")
+
+            describe ".not.rejectedWith(RangeError, 'foo')", =>
+                shouldFail
+                    op: => promise.should.not.be.rejectedWith(RangeError, "foo")
+                    message: "not to be rejected with 'RangeError' but it was rejected with 'RangeError: foo bar'"
+
             describe ".rejectedWith(RangeError, /bar/)", =>
                 shouldPass => promise.should.be.rejectedWith(RangeError, /bar/)
 
+            describe ".not.rejectedWith(RangeError, /bar/)", =>
+                shouldFail
+                    op: => promise.should.not.be.rejectedWith(RangeError, /bar/)
+                    message: "not to be rejected with 'RangeError' but it was rejected with 'RangeError: foo bar'"
+
             describe ".rejectedWith(RangeError, 'quux')", =>
                 shouldFail
                     op: => promise.should.be.rejectedWith(RangeError, "quux")
-                    message: "to be rejected with an error including 'quux' but got 'RangeError: foo bar'"
+                    message: "to be rejected with an error including 'quux' but got 'foo bar'"
             describe ".rejectedWith(RangeError, /quux/)", =>
                 shouldFail
                     op: => promise.should.be.rejectedWith(RangeError, /quux/)
-                    message: "to be rejected with an error matching /quux/ but got 'RangeError: foo bar'"
+                    message: "to be rejected with an error matching /quux/ but got 'foo bar'"
 
             describe ".rejectedWith(TypeError, 'foo')", =>
                 shouldFail
-                    op: => promise.should.be.rejectedWith(TypeError)
-                    message: "to be rejected with 'TypeError' but it was rejected with [RangeError: foo bar]"
+                    op: => promise.should.be.rejectedWith(TypeError, 'foo')
+                    message: "to be rejected with 'TypeError' but it was rejected with 'RangeError: foo bar'"
             describe ".rejectedWith(TypeError, /bar/)", =>
                 shouldFail
-                    op: => promise.should.be.rejectedWith(TypeError)
-                    message: "to be rejected with 'TypeError' but it was rejected with [RangeError: foo bar]"
+                    op: => promise.should.be.rejectedWith(TypeError, /bar/)
+                    message: "to be rejected with 'TypeError' but it was rejected with 'RangeError: foo bar'"
 
             describe ".rejectedWith(TypeError, 'quux')", =>
                 shouldFail
-                    op: => promise.should.be.rejectedWith(TypeError)
-                    message: "to be rejected with 'TypeError' but it was rejected with [RangeError: foo bar]"
+                    op: => promise.should.be.rejectedWith(TypeError, 'quux')
+                    message: "to be rejected with 'TypeError' but it was rejected with 'RangeError: foo bar'"
             describe ".rejectedWith(TypeError, /quux/)", =>
                 shouldFail
-                    op: => promise.should.be.rejectedWith(TypeError)
-                    message: "to be rejected with 'TypeError' but it was rejected with [RangeError: foo bar]"
+                    op: => promise.should.be.rejectedWith(TypeError, /quux/)
+                    message: "to be rejected with 'TypeError' but it was rejected with 'RangeError: foo bar'"
 
             describe ".not.rejectedWith(RangeError, 'foo')", =>
                 shouldFail
-                    op: => promise.should.not.be.rejectedWith(RangeError)
-                    message: "not to be rejected with 'RangeError' but it was rejected with [RangeError: foo bar]"
+                    op: => promise.should.not.be.rejectedWith(RangeError, 'foo')
+                    message: "not to be rejected with 'RangeError' but it was rejected with 'RangeError: foo bar'"
             describe ".not.rejectedWith(RangeError, /bar/)", =>
                 shouldFail
-                    op: => promise.should.not.be.rejectedWith(RangeError)
-                    message: "not to be rejected with 'RangeError' but it was rejected with [RangeError: foo bar]"
+                    op: => promise.should.not.be.rejectedWith(RangeError, /bar/)
+                    message: "not to be rejected with 'RangeError' but it was rejected with 'RangeError: foo bar'"
 
             describe ".not.rejectedWith(RangeError, 'quux')", =>
-                shouldFail
-                    op: => promise.should.not.be.rejectedWith(RangeError)
-                    message: "not to be rejected with 'RangeError' but it was rejected with [RangeError: foo bar]"
+                shouldPass => promise.should.not.be.rejectedWith(RangeError, 'quux')
             describe ".not.rejectedWith(RangeError, /quux/)", =>
-                shouldFail
-                    op: => promise.should.not.be.rejectedWith(RangeError)
-                    message: "not to be rejected with 'RangeError' but it was rejected with [RangeError: foo bar]"
-
+                shouldPass => promise.should.not.be.rejectedWith(RangeError, /quux/)
             describe ".not.rejectedWith(TypeError, 'foo')", =>
-                shouldFail
-                    op: => promise.should.not.be.rejectedWith(TypeError, "foo")
-                    message: "not to be rejected with an error including 'foo'"
+                shouldPass => promise.should.not.be.rejectedWith(TypeError, "foo")
             describe ".not.rejectedWith(TypeError, /bar/)", =>
-                shouldFail
-                    op: => promise.should.not.be.rejectedWith(TypeError, /bar/)
-                    message: "not to be rejected with an error matching /bar/"
-
+                shouldPass => promise.should.not.be.rejectedWith(TypeError, /bar/)
             describe ".not.rejectedWith(TypeError, 'quux')", =>
                 shouldPass => promise.should.not.be.rejectedWith(TypeError, "quux")
             describe ".not.rejectedWith(TypeError, /quux/)", =>
                 shouldPass => promise.should.not.be.rejectedWith(TypeError, /quux/)
+            describe ".rejectedWith(RangeError, 'foo', custom)", =>
+                shouldPass => promise.should.be.rejectedWith(RangeError, "foo", custom)
+
+            describe ".not.rejectedWith(RangeError, 'foo', custom)", =>
+                shouldFail
+                    op: => promise.should.not.be.rejectedWith(RangeError, "foo", custom)
+                    message: custom
+
+            describe ".rejectedWith(RangeError, /bar/, custom)", =>
+                shouldPass => promise.should.be.rejectedWith(RangeError, /bar/, custom)
+
+            describe ".not.rejectedWith(RangeError, /bar/, custom)", =>
+                shouldFail
+                    op: => promise.should.not.be.rejectedWith(RangeError, /bar/, custom)
+                    message: custom
+
+            describe ".rejectedWith(RangeError, 'quux', custom)", =>
+                shouldFail
+                    op: => promise.should.be.rejectedWith(RangeError, "quux", custom)
+                    message: custom
+
+            describe ".not.rejectedWith(TypeError, 'quux', custom)", =>
+                shouldPass => promise.should.not.be.rejectedWith(TypeError, "quux", custom)
+
+            describe ".rejectedWith(RangeError, /quux/, custom)", =>
+                shouldFail
+                    op: => promise.should.be.rejectedWith(RangeError, /quux/, custom)
+                    message: custom
+
+            describe ".not.rejectedWith(TypeError, /quux/, custom)", =>
+                shouldPass => promise.should.not.be.rejectedWith(TypeError, /quux/, custom)
+
+            describe ".rejectedWith(RangeError, undefined, custom)", =>
+                shouldPass => promise.should.be.rejectedWith(RangeError, undefined, custom)
+
+            describe ".not.rejectedWith(RangeError, undefined, custom)", =>
+                shouldFail
+                    op: => promise.should.not.be.rejectedWith(RangeError, undefined, custom)
+                    message: custom
+
+            describe ".rejectedWith(TypeError, undefined, custom)", =>
+                shouldFail
+                op: => promise.should.be.rejectedWith(TypeError, undefined, custom)
+                message: custom
+
+            describe ".not.rejectedWith(TypeError, undefined, custom)", =>
+                shouldPass => promise.should.not.be.rejectedWith(TypeError, undefined, custom)
 
         describe ".should.notify(done)", =>
             it "should fail the test with the original error", (done) =>
diff --git a/test/support/common.js b/test/support/common.js
index b11681c..b58ef2e 100644
--- a/test/support/common.js
+++ b/test/support/common.js
@@ -25,22 +25,27 @@ global.shouldPass = function (promiseProducer) {
 global.shouldFail = function (options) {
     var promiseProducer = options.op;
     var desiredMessageSubstring = options.message;
+    var nonDesiredMessageSubstring = options.notMessage;
 
     it("should return a promise rejected with an assertion error", function (done) {
         promiseProducer().then(function () {
-            done(new Error("Expected promise to be rejected with an assertion error, but it was fulfilled"));
+            throw new Error("Expected promise to be rejected with an assertion error, but it was fulfilled");
         }, function (reason) {
             if (Object(reason) !== reason || reason.constructor.name !== "AssertionError") {
-                done(new Error("Expected promise to be rejected with an AssertionError but it was rejected with " +
-                               reason));
-            } else {
-                if (desiredMessageSubstring && reason.message.indexOf(desiredMessageSubstring) === -1) {
-                    done(new Error("Expected promise to be rejected with an AssertionError containing \"" +
-                                   desiredMessageSubstring + "\" but it was rejected with " + reason));
-                } else {
-                    done();
-                }
+                throw new Error("Expected promise to be rejected with an AssertionError but it was rejected with " +
+                                reason);
             }
-        });
+
+            if (desiredMessageSubstring && reason.message.indexOf(desiredMessageSubstring) === -1) {
+                throw new Error("Expected promise to be rejected with an AssertionError containing \"" +
+                                desiredMessageSubstring + "\" but it was rejected with " + reason);
+            }
+
+            if (nonDesiredMessageSubstring && reason.message.indexOf(nonDesiredMessageSubstring) !== -1) {
+                throw new Error("Expected promise to be rejected with an AssertionError not containing \"" +
+                                nonDesiredMessageSubstring + "\" but it was rejected with " + reason);
+            }
+        }).then(done, done);
+
     });
 };