function assertIncreases (subject, prop, msg) {
    if (msg) flag(this, 'message', msg);
    var fn = flag(this, 'object')
      , flagMsg = flag(this, 'message')
      , ssfi = flag(this, 'ssfi');
    new Assertion(fn, flagMsg, ssfi, true).is.a('function');

    var initial;
    if (!prop) {
      new Assertion(subject, flagMsg, ssfi, true).is.a('function');
      initial = subject();
    } else {
      new Assertion(subject, flagMsg, ssfi, true).to.have.property(prop);
      initial = subject[prop];
    }

    // Make sure that the target is a number
    new Assertion(initial, flagMsg, ssfi, true).is.a('number');

    fn();

    var final = prop === undefined || prop === null ? subject() : subject[prop];
    var msgObj = prop === undefined || prop === null ? initial : '.' + prop;

    flag(this, 'deltaMsgObj', msgObj);
    flag(this, 'initialDeltaValue', initial);
    flag(this, 'finalDeltaValue', final);
    flag(this, 'deltaBehavior', 'increase');
    flag(this, 'realDelta', final - initial);

    this.assert(
      final - initial > 0
      , 'expected ' + msgObj + ' to increase'
      , 'expected ' + msgObj + ' to not increase'
    );
  }
### .increase(subject[, prop[, msg]])

When one argument is provided, `.increase` asserts that the given function
`subject` returns a greater number when it's invoked after invoking the
target function compared to when it's invoked beforehand. `.increase` also
causes all `.by` assertions that follow in the chain to assert how much
greater of a number is returned. It's often best to assert that the return
value increased by the expected amount, rather than asserting it increased
by any amount.

    var val = 1
      , addTwo = function () { val += 2; }
      , getVal = function () { return val; };

    expect(addTwo).to.increase(getVal).by(2); // Recommended
    expect(addTwo).to.increase(getVal); // Not recommended

When two arguments are provided, `.increase` asserts that the value of the
given object `subject`'s `prop` property is greater after invoking the
target function compared to beforehand.

    var myObj = {val: 1}
      , addTwo = function () { myObj.val += 2; };

    expect(addTwo).to.increase(myObj, 'val').by(2); // Recommended
    expect(addTwo).to.increase(myObj, 'val'); // Not recommended

Add `.not` earlier in the chain to negate `.increase`. However, it's
dangerous to do so. The problem is that it creates uncertain expectations
by asserting that the subject either decreases, or that it stays the same.
It's often best to identify the exact output that's expected, and then
write an assertion that only accepts that exact output.

When the subject is expected to decrease, it's often best to assert that it
decreased by the expected amount.

    var myObj = {val: 1}
      , subtractTwo = function () { myObj.val -= 2; };

    expect(subtractTwo).to.decrease(myObj, 'val').by(2); // Recommended
    expect(subtractTwo).to.not.increase(myObj, 'val'); // Not recommended

When the subject is expected to stay the same, it's often best to assert
exactly that.

    var myObj = {val: 1}
      , noop = function () {};

    expect(noop).to.not.change(myObj, 'val'); // Recommended
    expect(noop).to.not.increase(myObj, 'val'); // Not recommended

`.increase` accepts an optional `msg` argument which is a custom error
message to show when the assertion fails. The message can also be given as
the second argument to `expect`. When not providing two arguments, always
use the second form.

    var myObj = {val: 1}
      , noop = function () {};

    expect(noop).to.increase(myObj, 'val', 'nooo why fail??');

    var val = 1
      , noop = function () {}
      , getVal = function () { return val; };

    expect(noop, 'nooo why fail??').to.increase(getVal);

The alias `.increases` can be used interchangeably with `.increase`.

@name increase
@alias increases
@param {String|Function} subject
@param {String} prop name _optional_
@param {String} msg _optional_
@namespace BDD
@api public