/// <reference path="../jasmine/jasmine.d.ts" />
/// <reference path="jasmine-expect.d.ts" />

// Taken directly from the test directory of the original repo

declare var describeWhenNotArray: (arr: string) => void;
declare var describeToBeArrayOfX: (arr: string, descriptor: {}) => void;
declare var describeToHaveArrayX: (arr: string, descriptor: () => void) => void;
declare var describeToHaveX: (arr: string, descriptor: () => void) => void;
declare var describeToHaveBooleanX: (arr: string, descriptor: () => void) => void;
declare var badReference: { someValue: any };
var _undefined: any = undefined;

describe('toBeAfter', function() {
  describe('when invoked', function() {
    describe('when value is a Date', function() {
      describe('when date occurs after another', function() {
        it('should confirm', function() {
          expect(new Date('2013-01-01T01:00:00.000Z')).toBeAfter(new Date('2013-01-01T00:00:00.000Z'));
        });
      });
      describe('when date does NOT occur after another', function() {
        it('should deny', function() {
          expect(new Date('2013-01-01T00:00:00.000Z')).not.toBeAfter(new Date('2013-01-01T01:00:00.000Z'));
        });
      });
    });
  });
});


describe('toBeArray', function() {
  describe('when invoked', function() {
    describe('when subject is a true Array', function() {
      it('should confirm', function() {
        expect([]).toBeArray();
        expect(new Array()).toBeArray();
      });
    });
    describeWhenNotArray('toBeArray');
  });
});


describe('toBeArrayOfBooleans', function() {
  describeToBeArrayOfX('toBeArrayOfBooleans', {
    type: 'Boolean',
    whenValid: function() {
      expect([true]).toBeArrayOfBooleans();
      expect([new Boolean(true)]).toBeArrayOfBooleans();
      expect([new Boolean(false)]).toBeArrayOfBooleans();
      expect([false, true]).toBeArrayOfBooleans();
    },
    whenInvalid: function() {
      expect([null]).not.toBeArrayOfBooleans();
    },
    whenMixed: function() {
      expect([null, false]).not.toBeArrayOfBooleans();
      expect([null, true]).not.toBeArrayOfBooleans();
    }
  });
});


describe('toBeArrayOfNumbers', function() {
  describeToBeArrayOfX('toBeArrayOfNumbers', {
    type: 'Number',
    whenValid: function() {
      expect([1]).toBeArrayOfNumbers();
      expect([new Number(1)]).toBeArrayOfNumbers();
      expect([new Number(0)]).toBeArrayOfNumbers();
      expect([0, 1]).toBeArrayOfNumbers();
    },
    whenInvalid: function() {
      expect([null]).not.toBeArrayOfNumbers();
    },
    whenMixed: function() {
      expect([null, 0]).not.toBeArrayOfNumbers();
    }
  });
});

describe('toBeArrayOfObjects', function() {
  describeToBeArrayOfX('toBeArrayOfObjects', {
    type: 'Object',
    whenValid: function() {
      expect([{}, {}]).toBeArrayOfObjects();
    },
    whenInvalid: function() {
      expect([null]).not.toBeArrayOfObjects();
      expect(['Object']).not.toBeArrayOfObjects();
      expect(['[object Object]']).not.toBeArrayOfObjects();
    },
    whenMixed: function() {
      expect([null, {}]).not.toBeArrayOfObjects();
    }
  });
});

describe('toBeArrayOfSize', function() {
  describe('when invoked', function() {
    describe('when subject is a true Array', function() {
      describe('when subject has the expected number of members', function() {
        it('should confirm', function() {
          expect([]).toBeArrayOfSize(0);
          expect([null]).toBeArrayOfSize(1);
          expect([false, false]).toBeArrayOfSize(2);
          expect([_undefined, _undefined]).toBeArrayOfSize(2);
        });
      });
      describe('when subject has an unexpected number of members', function() {
        it('should deny', function() {
          expect([]).not.toBeArrayOfSize(1);
          expect([null]).not.toBeArrayOfSize(0);
          expect([true, true]).not.toBeArrayOfSize(1);
        });
      });
    });
    describeWhenNotArray('toBeArrayOfSize');
  });
});


describe('toBeArrayOfStrings', function() {
  describeToBeArrayOfX('toBeArrayOfStrings', {
    type: 'String',
    whenValid: function() {
      expect(['truthy']).toBeArrayOfStrings();
      expect([new String('truthy')]).toBeArrayOfStrings();
      expect([new String('')]).toBeArrayOfStrings();
      expect(['', 'truthy']).toBeArrayOfStrings();
    },
    whenInvalid: function() {
      expect([null]).not.toBeArrayOfStrings();
    },
    whenMixed: function() {
      expect([null, '']).not.toBeArrayOfStrings();
    }
  });
});

describe('toBeBefore', function() {
  describe('when invoked', function() {
    describe('when value is a Date', function() {
      describe('when date occurs before another', function() {
        it('should confirm', function() {
          expect(new Date('2013-01-01T00:00:00.000Z')).toBeBefore(new Date('2013-01-01T01:00:00.000Z'));
        });
      });
      describe('when date does NOT occur before another', function() {
        it('should deny', function() {
          expect(new Date('2013-01-01T01:00:00.000Z')).not.toBeBefore(new Date('2013-01-01T00:00:00.000Z'));
        });
      });
    });
  });
});


describe('toBeBoolean', function() {
  describe('when invoked', function() {
    describe('when subject not only truthy or falsy, but a boolean', function() {
      it('should confirm', function() {
        expect(true).toBeBoolean();
        expect(false).toBeBoolean();
        expect(new Boolean(true)).toBeBoolean();
        expect(new Boolean(false)).toBeBoolean();
      });
    });
    describe('when subject is truthy or falsy', function() {
      it('should deny', function() {
        expect(1).not.toBeBoolean();
        expect(0).not.toBeBoolean();
      });
    });
  });
});

describe('toBeCalculable', function() {
  describe('when invoked', function() {
    describe('when subject CAN be coerced to be used in mathematical operations', function() {
      it('should confirm', function() {
        expect('1').toBeCalculable();
        expect('').toBeCalculable();
        expect(null).toBeCalculable();
      });
    });
    describe('when subject can NOT be coerced by JavaScript to be used in mathematical operations', function() {
      it('should deny', function() {
        expect({}).not.toBeCalculable();
        expect(NaN).not.toBeCalculable();
      });
    });
  });
});

describe('toBeDate', function() {
  describe('when invoked', function() {
    describe('when value is an instance of Date', function() {
      it('should confirm', function() {
        expect(new Date()).toBeDate();
      });
    });
    describe('when value is NOT an instance of Date', function() {
      it('should deny', function() {
        expect(null).not.toBeDate();
      });
    });
  });
});

describe('toBeEmptyArray', function() {
  describe('when invoked', function() {
    describe('when subject is a true Array', function() {
      describe('when subject has members', function() {
        it('should confirm', function() {
          expect([]).toBeEmptyArray();
        });
      });
      describe('when subject has no members', function() {
        it('should deny', function() {
          expect([null]).not.toBeEmptyArray();
          expect(['']).not.toBeEmptyArray();
          expect([1]).not.toBeEmptyArray();
          expect([true]).not.toBeEmptyArray();
          expect([false]).not.toBeEmptyArray();
        });
      });
    });
    describeWhenNotArray('toBeEmptyArray');
  });
});

describe('toBeEmptyObject', function() {
  beforeEach(function() {
    this.Foo = function() { };
  });
  describe('when invoked', function() {
    describe('when subject IS an Object with no instance members', function() {
      beforeEach(function() {
        this.Foo.prototype = {
          b: 2
        };
      });
      it('should confirm', function() {
        expect(new this.Foo()).toBeEmptyObject();
        expect({}).toBeEmptyObject();
      });
    });
    describe('when subject is NOT an Object with no instance members', function() {
      it('should deny', function() {
        expect({
          a: 1
        }).not.toBeEmptyObject();
        expect(null).not.toBeNonEmptyObject();
      });
    });
  });
});

describe('toBeEmptyString', function() {
  describe('when invoked', function() {
    describe('when subject IS a string with no characters', function() {
      it('should confirm', function() {
        expect('').toBeEmptyString();
      });
    });
    describe('when subject is NOT a string with no characters', function() {
      it('should deny', function() {
        expect(' ').not.toBeEmptyString();
      });
    });
  });
});

describe('toBeEvenNumber', function() {
  describe('when invoked', function() {
    describe('when subject IS an even number', function() {
      it('should confirm', function() {
        expect(2).toBeEvenNumber();
      });
    });
    describe('when subject is NOT an even number', function() {
      it('should deny', function() {
        expect(1).not.toBeEvenNumber();
        expect(NaN).not.toBeEvenNumber();
      });
    });
  });
});


describe('toBeFalse', function() {
  describe('when invoked', function() {
    describe('when subject is not only falsy, but a boolean false', function() {
      it('should confirm', function() {
        expect(false).toBeFalse();
        expect(new Boolean(false)).toBeFalse();
      });
    });
    describe('when subject is falsy', function() {
      it('should deny', function() {
        expect(1).not.toBeFalse();
      });
    });
  });
});

describe('toBeFunction', function() {
  describe('when invoked', function() {
    describe('when subject IS a function', function() {
      it('should confirm', function() {
        expect(function() { }).toBeFunction();
      });
    });
    describe('when subject is NOT a function', function() {
      it('should deny', function() {
        expect(/regexp/).not.toBeFunction();
      });
    });
  });
});

describe('toBeHtmlString', function() {
  describe('when invoked', function() {
    describe('when subject IS a string of HTML markup', function() {
      beforeEach(function() {
        this.ngMultiLine = '';
        this.ngMultiLine += '<a data-ng-href="//www.google.com" data-ng-click="launchApp($event)" target="_blank" class="ng-binding" href="//www.google.com">';
        this.ngMultiLine += '\n';
        this.ngMultiLine += '  Watch with Google TV';
        this.ngMultiLine += '\n';
        this.ngMultiLine += '</a>';
        this.ngMultiLine += '\n';
      });
      it('should confirm', function() {
        expect('<element>text</element>').toBeHtmlString();
        expect('<a data-ng-href="//foo.com" data-ng-click="bar($event)">baz</a>').toBeHtmlString();
        expect('<div ng-if="foo > bar || bar < foo && baz == bar"></div>').toBeHtmlString();
        expect('<li ng-if="foo > bar || bar < foo && baz == bar">').toBeHtmlString();
        expect(this.ngMultiLine).toBeHtmlString();
      });
    });
    describe('when subject is NOT a string of HTML markup', function() {
      it('should deny', function() {
        expect('div').not.toBeHtmlString();
        expect(null).not.toBeHtmlString();
      });
    });
  });
});

describe('toBeIso8601', function() {
  describe('when invoked', function() {
    describe('when value is a Date String conforming to the ISO 8601 standard', function() {
      describe('when specified date is valid', function() {
        it('should confirm', function() {
          expect('2013-07-08T07:29:15.863Z').toBeIso8601();
          expect('2013-07-08T07:29:15.863').toBeIso8601();
          expect('2013-07-08T07:29:15').toBeIso8601();
          expect('2013-07-08T07:29').toBeIso8601();
          expect('2013-07-08').toBeIso8601();
        });
      });
      describe('when specified date is NOT valid', function() {
        it('should deny', function() {
          expect('2013-99-12T00:00:00.000Z').not.toBeIso8601();
          expect('2013-12-99T00:00:00.000Z').not.toBeIso8601();
          expect('2013-01-01T99:00:00.000Z').not.toBeIso8601();
          expect('2013-01-01T99:99:00.000Z').not.toBeIso8601();
          expect('2013-01-01T00:00:99.000Z').not.toBeIso8601();
        });
      });
    });
    describe('when value is a String NOT conforming to the ISO 8601 standard', function() {
      it('should deny', function() {
        expect('2013-07-08T07:29:15.').not.toBeIso8601();
        expect('2013-07-08T07:29:').not.toBeIso8601();
        expect('2013-07-08T07:2').not.toBeIso8601();
        expect('2013-07-08T07:').not.toBeIso8601();
        expect('2013-07-08T07').not.toBeIso8601();
        expect('2013-07-08T').not.toBeIso8601();
        expect('2013-07-0').not.toBeIso8601();
        expect('2013-07-').not.toBeIso8601();
        expect('2013-07').not.toBeIso8601();
        expect('2013-0').not.toBeIso8601();
        expect('2013-').not.toBeIso8601();
        expect('2013').not.toBeIso8601();
        expect('201').not.toBeIso8601();
        expect('20').not.toBeIso8601();
        expect('2').not.toBeIso8601();
        expect('').not.toBeIso8601();
      });
    });
  });
});
var _undefined;

describe('toBeJsonString', function() {
  describe('when invoked', function() {
    describe('when subject IS a string of parseable JSON', function() {
      it('should confirm', function() {
        expect('{}').toBeJsonString();
        expect('[]').toBeJsonString();
        expect('[1]').toBeJsonString();
      });
    });
    describe('when subject is NOT a string of parseable JSON', function() {
      it('should deny', function() {
        expect('[1,]').not.toBeJsonString();
        expect('<>').not.toBeJsonString();
        expect(null).not.toBeJsonString();
        expect('').not.toBeJsonString();
        expect(_undefined).not.toBeJsonString();
      });
    });
  });
});

describe('toBeLongerThan', function() {
  describe('when invoked', function() {
    describe('when the subject and comparison ARE both strings', function() {
      describe('when the subject IS longer than the comparision string', function() {
        it('should confirm', function() {
          expect('abc').toBeLongerThan('ab');
          expect('a').toBeLongerThan('');
        });
      });
      describe('when the subject is NOT longer than the comparision string', function() {
        it('should deny', function() {
          expect('ab').not.toBeLongerThan('abc');
          expect('').not.toBeLongerThan('a');
        });
      });
    });
    describe('when the subject and comparison are NOT both strings', function() {
      it('should deny (we are asserting the relative lengths of two strings)', function() {
        expect('truthy').not.toBeLongerThan(_undefined);
        expect(_undefined).not.toBeLongerThan('truthy');
        expect('').not.toBeLongerThan(_undefined);
        expect(_undefined).not.toBeLongerThan('');
      });
    });
  });
});

describe('toBeNonEmptyArray', function() {
  describe('when invoked', function() {
    describe('when subject is a true Array', function() {
      describe('when subject has members', function() {
        it('should confirm', function() {
          expect([null]).toBeNonEmptyArray();
          expect([_undefined]).toBeNonEmptyArray();
          expect(['']).toBeNonEmptyArray();
        });
      });
      describe('when subject has no members', function() {
        it('should deny', function() {
          expect([]).not.toBeNonEmptyArray();
        });
      });
    });
    describeWhenNotArray('toBeNonEmptyArray');
  });
});

describe('toBeNonEmptyObject', function() {
  beforeEach(function() {
    this.Foo = function() { };
  });
  describe('when invoked', function() {
    describe('when subject IS an Object with at least one instance member', function() {
      it('should confirm', function() {
        expect({
          a: 1
        }).toBeNonEmptyObject();
      });
    });
    describe('when subject is NOT an Object with at least one instance member', function() {
      beforeEach(function() {
        this.Foo.prototype = {
          b: 2
        };
      });
      it('should deny', function() {
        expect(new this.Foo()).not.toBeNonEmptyObject();
        expect({}).not.toBeNonEmptyObject();
        expect(null).not.toBeNonEmptyObject();
      });
    });
  });
});

describe('toBeNonEmptyString', function() {
  describe('when invoked', function() {
    describe('when subject IS a string with at least one character', function() {
      it('should confirm', function() {
        expect(' ').toBeNonEmptyString();
      });
    });
    describe('when subject is NOT a string with at least one character', function() {
      it('should deny', function() {
        expect('').not.toBeNonEmptyString();
        expect(null).not.toBeNonEmptyString();
      });
    });
  });
});

describe('toBeNumber', function() {
  describe('when invoked', function() {
    describe('when subject IS a number', function() {
      it('should confirm', function() {
        expect(1).toBeNumber();
        expect(1.11).toBeNumber();
        expect(1e3).toBeNumber();
        expect(0.11).toBeNumber();
        expect(-11).toBeNumber();
      });
    });
    describe('when subject is NOT a number', function() {
      it('should deny', function() {
        expect('1').not.toBeNumber();
        expect(NaN).not.toBeNumber();
      });
    });
  });
});


describe('toBeObject', function() {
  beforeEach(function() {
    this.Foo = function() { };
  });
  describe('when invoked', function() {
    describe('when subject IS an Object', function() {
      it('should confirm', function() {
        expect(new Object()).toBeObject();
        expect(new this.Foo()).toBeObject();
        expect({}).toBeObject();
      });
    });
    describe('when subject is NOT an Object', function() {
      it('should deny', function() {
        expect(null).not.toBeObject();
        expect(123).not.toBeObject();
        expect('[object Object]').not.toBeObject();
      });
    });
  });
});

describe('toBeOddNumber', function() {
  describe('when invoked', function() {
    describe('when subject IS an odd number', function() {
      it('should confirm', function() {
        expect(1).toBeOddNumber();
      });
    });
    describe('when subject is NOT an odd number', function() {
      it('should deny', function() {
        expect(2).not.toBeOddNumber();
        expect(NaN).not.toBeOddNumber();
      });
    });
  });
});
var _undefined;

describe('toBeSameLengthAs', function() {
  describe('when invoked', function() {
    describe('when the subject and comparison ARE both strings', function() {
      describe('when the subject IS the same length as the comparision string', function() {
        it('should confirm', function() {
          expect('ab').toBeSameLengthAs('ab');
        });
      });
      describe('when the subject is NOT the same length as the comparision string', function() {
        it('should deny', function() {
          expect('abc').not.toBeSameLengthAs('ab');
          expect('a').not.toBeSameLengthAs('');
          expect('').not.toBeSameLengthAs('a');
        });
      });
    });
    describe('when the subject and comparison are NOT both strings', function() {
      it('should deny (we are asserting the relative lengths of two strings)', function() {
        expect('truthy').not.toBeSameLengthAs(_undefined);
        expect(_undefined).not.toBeSameLengthAs('truthy');
        expect('').not.toBeSameLengthAs(_undefined);
        expect(_undefined).not.toBeSameLengthAs('');
      });
    });
  });
});
var _undefined;

describe('toBeShorterThan', function() {
  describe('when invoked', function() {
    describe('when the subject and comparison ARE both strings', function() {
      describe('when the subject IS shorter than the comparision string', function() {
        it('should confirm', function() {
          expect('ab').toBeShorterThan('abc');
          expect('').toBeShorterThan('a');
        });
      });
      describe('when the subject is NOT shorter than the comparision string', function() {
        it('should deny', function() {
          expect('abc').not.toBeShorterThan('ab');
          expect('a').not.toBeShorterThan('');
        });
      });
    });
    describe('when the subject and comparison are NOT both strings', function() {
      it('should deny (we are asserting the relative lengths of two strings)', function() {
        expect('truthy').not.toBeShorterThan(_undefined);
        expect(_undefined).not.toBeShorterThan('truthy');
        expect('').not.toBeShorterThan(_undefined);
        expect(_undefined).not.toBeShorterThan('');
      });
    });
  });
});

describe('toBeString', function() {
  describe('when invoked', function() {
    describe('when subject IS a string of any length', function() {
      it('should confirm', function() {
        expect('').toBeString();
        expect(' ').toBeString();
      });
    });
    describe('when subject is NOT a string of any length', function() {
      it('should deny', function() {
        expect(null).not.toBeString();
      });
    });
  });
});


describe('toBeTrue', function() {
  describe('when invoked', function() {
    describe('when subject is not only truthy, but a boolean true', function() {
      it('should confirm', function() {
        expect(true).toBeTrue();
        expect(new Boolean(true)).toBeTrue();
      });
    });
    describe('when subject is truthy', function() {
      it('should deny', function() {
        expect(1).not.toBeTrue();
      });
    });
  });
});

describe('toBeWhitespace', function() {
  describe('when invoked', function() {
    describe('when subject IS a string containing only tabs, spaces, returns etc', function() {
      it('should confirm', function() {
        expect(' ').toBeWhitespace();
        expect('').toBeWhitespace();
      });
    });
    describe('when subject is NOT a string containing only tabs, spaces, returns etc', function() {
      it('should deny', function() {
        expect('has-no-whitespace').not.toBeWhitespace();
        expect('has whitespace').not.toBeWhitespace();
        expect(null).not.toBeWhitespace();
      });
    });
  });
});

describe('toBeWholeNumber', function() {
  describe('when invoked', function() {
    describe('when subject IS a number with no positive decimal places', function() {
      it('should confirm', function() {
        expect(1).toBeWholeNumber();
        expect(0).toBeWholeNumber();
        expect(0.0).toBeWholeNumber();
      });
    });
    describe('when subject is NOT a number with no positive decimal places', function() {
      it('should deny', function() {
        expect(NaN).not.toBeWholeNumber();
        expect(1.1).not.toBeWholeNumber();
        expect(0.1).not.toBeWholeNumber();
      });
    });
  });
});

describe('toBeWithinRange', function() {
  describe('when invoked', function() {
    describe('when subject IS a number >= floor and <= ceiling', function() {
      it('should confirm', function() {
        expect(0).toBeWithinRange(0, 2);
        expect(1).toBeWithinRange(0, 2);
        expect(2).toBeWithinRange(0, 2);
      });
    });
    describe('when subject is NOT a number >= floor and <= ceiling', function() {
      it('should deny', function() {
        expect(-3).not.toBeWithinRange(0, 2);
        expect(-2).not.toBeWithinRange(0, 2);
        expect(-1).not.toBeWithinRange(0, 2);
        expect(3).not.toBeWithinRange(0, 2);
        expect(NaN).not.toBeWithinRange(0, 2);
      });
    });
  });
});
var _undefined;

describe('toEndWith', function() {
  describe('when invoked', function() {
    describe('when subject is NOT an undefined or empty string', function() {
      describe('when subject is a string whose trailing characters match the expected string', function() {
        it('should confirm', function() {
          expect('jamie').toEndWith('mie');
        });
      });
      describe('when subject is a string whose trailing characters DO NOT match the expected string', function() {
        it('should deny', function() {
          expect('jamie ').not.toEndWith('mie');
          expect('jamiE').not.toEndWith('mie');
        });
      });
    });
    describe('when subject IS an undefined or empty string', function() {
      it('should deny', function() {
        expect('').not.toEndWith('');
        expect(_undefined).not.toEndWith('');
        expect(_undefined).not.toEndWith('undefined');
        expect('undefined').not.toEndWith(_undefined);
      });
    });
  });
});

describe('toHaveArray', function() {
  describeToHaveArrayX('toHaveArray', function() {
    it('should confirm', function() {
      expect({
        memberName: []
      }).toHaveArray('memberName');
      expect({
        memberName: [1, 2, 3]
      }).toHaveArray('memberName');
    });
  });
});


describe('toHaveArrayOfBooleans', function() {
  describeToHaveArrayX('toHaveArrayOfBooleans', function() {
    describe('when named Array is empty', function() {
      it('should confirm', function() {
        expect({
          memberName: []
        }).toHaveArrayOfBooleans('memberName');
      });
    });
    describe('when named Array has items', function() {
      describe('when all items are booleans', function() {
        it('should confirm', function() {
          expect({
            memberName: [true]
          }).toHaveArrayOfBooleans('memberName');
          expect({
            memberName: [new Boolean(true)]
          }).toHaveArrayOfBooleans('memberName');
          expect({
            memberName: [new Boolean(false)]
          }).toHaveArrayOfBooleans('memberName');
          expect({
            memberName: [false, true]
          }).toHaveArrayOfBooleans('memberName');
        });
      });
      describe('when any item is not a boolean', function() {
        it('should deny', function() {
          expect({
            memberName: [null]
          }).not.toHaveArrayOfBooleans('memberName');
          expect({
            memberName: [null, false]
          }).not.toHaveArrayOfBooleans('memberName');
        });
      });
    });
  });
});


describe('toHaveArrayOfNumbers', function() {
  describeToHaveArrayX('toHaveArrayOfNumbers', function() {
    describe('when named Array is empty', function() {
      it('should confirm', function() {
        expect({
          memberName: []
        }).toHaveArrayOfNumbers('memberName');
      });
    });
    describe('when named Array has items', function() {
      describe('when all items are numbers', function() {
        it('should confirm', function() {
          expect({
            memberName: [1]
          }).toHaveArrayOfNumbers('memberName');
          expect({
            memberName: [new Number(1)]
          }).toHaveArrayOfNumbers('memberName');
          expect({
            memberName: [new Number(0)]
          }).toHaveArrayOfNumbers('memberName');
          expect({
            memberName: [0, 1]
          }).toHaveArrayOfNumbers('memberName');
        });
      });
      describe('when any item is not a number', function() {
        it('should deny', function() {
          expect({
            memberName: [null]
          }).not.toHaveArrayOfNumbers('memberName');
          expect({
            memberName: [null, 0]
          }).not.toHaveArrayOfNumbers('memberName');
        });
      });
    });
  });
});

describe('toHaveArrayOfObjects', function() {
  describeToHaveArrayX('toHaveArrayOfObjects', function() {
    describe('when named Array is empty', function() {
      it('should confirm', function() {
        expect({
          memberName: []
        }).toHaveArrayOfObjects('memberName');
      });
    });
    describe('when named Array has items', function() {
      describe('when all items are objects', function() {
        it('should confirm', function() {
          expect({
            memberName: [{}]
          }).toHaveArrayOfObjects('memberName');
          expect({
            memberName: [{}, {}]
          }).toHaveArrayOfObjects('memberName');
        });
      });
      describe('when any item is not an object', function() {
        it('should deny', function() {
          expect({
            memberName: [null]
          }).not.toHaveArrayOfObjects('memberName');
          expect({
            memberName: [null, {}]
          }).not.toHaveArrayOfObjects('memberName');
        });
      });
    });
  });
});

describe('toHaveArrayOfSize', function() {
  describeToHaveArrayX('toHaveArrayOfSize', function() {
    describe('when number of expected items does not match', function() {
      it('should deny', function() {
        expect({
          memberName: ''
        }).not.toHaveArrayOfSize('memberName');
        expect({
          memberName: ['bar']
        }).not.toHaveArrayOfSize('memberName', 0);
      });
    });
    describe('when number of expected items does match', function() {
      it('should confirm', function() {
        expect({
          memberName: []
        }).toHaveArrayOfSize('memberName', 0);
        expect({
          memberName: ['bar']
        }).toHaveArrayOfSize('memberName', 1);
        expect({
          memberName: ['bar', 'baz']
        }).toHaveArrayOfSize('memberName', 2);
      });
    });
  });
});


describe('toHaveArrayOfStrings', function() {
  describeToHaveArrayX('toHaveArrayOfStrings', function() {
    describe('when named Array is empty', function() {
      it('should confirm', function() {
        expect({
          memberName: []
        }).toHaveArrayOfStrings('memberName');
      });
    });
    describe('when named Array has items', function() {
      describe('when all items are strings', function() {
        it('should confirm', function() {
          expect({
            memberName: ['truthy']
          }).toHaveArrayOfStrings('memberName');
          expect({
            memberName: [new String('truthy')]
          }).toHaveArrayOfStrings('memberName');
          expect({
            memberName: [new String('')]
          }).toHaveArrayOfStrings('memberName');
          expect({
            memberName: ['', 'truthy']
          }).toHaveArrayOfStrings('memberName');
        });
      });
      describe('when any item is not a string', function() {
        it('should deny', function() {
          expect({
            memberName: [null]
          }).not.toHaveArrayOfStrings('memberName');
          expect({
            memberName: [null, '']
          }).not.toHaveArrayOfStrings('memberName');
        });
      });
    });
  });
});


describe('toHaveBoolean', function() {
  describeToHaveBooleanX('toHaveBoolean', function() {
    describe('when primitive', function() {
      it('should confirm', function() {
        expect({
          memberName: true
        }).toHaveBoolean('memberName');
        expect({
          memberName: false
        }).toHaveBoolean('memberName');
      });
    });
    describe('when Boolean object', function() {
      it('should confirm', function() {
        expect({
          memberName: new Boolean(true)
        }).toHaveBoolean('memberName');
        expect({
          memberName: new Boolean(false)
        }).toHaveBoolean('memberName');
      });
    });
  });
});

describe('toHaveCalculable', function() {
  describeToHaveX('toHaveCalculable', function() {
    describe('when subject CAN be coerced to be used in mathematical operations', function() {
      it('should confirm', function() {
        expect({
          memberName: '1'
        }).toHaveCalculable('memberName');
        expect({
          memberName: ''
        }).toHaveCalculable('memberName');
        expect({
          memberName: null
        }).toHaveCalculable('memberName');
      });
    });
    describe('when subject can NOT be coerced by JavaScript to be used in mathematical operations', function() {
      it('should deny', function() {
        expect({
          memberName: {}
        }).not.toHaveCalculable('memberName');
        expect({
          memberName: NaN
        }).not.toHaveCalculable('memberName');
      });
    });
  });
});

describe('toHaveDate', function() {
  var mockDate: any;
  beforeEach(function() {
    mockDate = {
      any: new Date(),
      early: new Date('2013-01-01T00:00:00.000Z'),
      late: new Date('2013-01-01T01:00:00.000Z')
    };
  });
  describeToHaveX('toHaveDate', function() {
    describe('when member is an instance of Date', function() {
      it('should confirm', function() {
        expect({
          memberName: mockDate.any
        }).toHaveDate('memberName');
      });
    });
    describe('when member is NOT an instance of Date', function() {
      it('should deny', function() {
        expect({
          memberName: null
        }).not.toHaveDate('memberName');
      });
    });
  });
});

describe('toHaveDateAfter', function() {
  var mockDate: any;
  beforeEach(function() {
    mockDate = {
      any: new Date(),
      early: new Date('2013-01-01T00:00:00.000Z'),
      late: new Date('2013-01-01T01:00:00.000Z')
    };
  });
  describeToHaveX('toHaveDateAfter', function() {
    describe('when member is an instance of Date', function() {
      describe('when date occurs before another', function() {
        it('should confirm', function() {
          expect({
            memberName: mockDate.late
          }).toHaveDateAfter('memberName', mockDate.early);
        });
      });
      describe('when date does NOT occur before another', function() {
        it('should deny', function() {
          expect({
            memberName: mockDate.early
          }).not.toHaveDateAfter('memberName', mockDate.late);
        });
      });
    });
    describe('when member is NOT an instance of Date', function() {
      it('should deny', function() {
        expect({
          memberName: null
        }).not.toHaveDateAfter('memberName', mockDate.any);
      });
    });
  });
});

describeToHaveX('toHaveDateBefore', function() {
  var mockDate: any;
  beforeEach(function() {
    mockDate = {
      any: new Date(),
      early: new Date('2013-01-01T00:00:00.000Z'),
      late: new Date('2013-01-01T01:00:00.000Z')
    };
  });
  describe('when member is an instance of Date', function() {
    describe('when date occurs before another', function() {
      it('should confirm', function() {
        expect({
          memberName: mockDate.early
        }).toHaveDateBefore('memberName', mockDate.late);
      });
    });
    describe('when date does NOT occur before another', function() {
      it('should deny', function() {
        expect({
          memberName: mockDate.late
        }).not.toHaveDateBefore('memberName', mockDate.early);
      });
    });
  });
  describe('when member is NOT an instance of Date', function() {
    it('should deny', function() {
      expect({
        memberName: null
      }).not.toHaveDateBefore('memberName', mockDate.any);
    });
  });
});

describe('toHaveEmptyArray', function() {
  describeToHaveArrayX('toHaveEmptyArray', function() {
    describe('when named array has members', function() {
      it('should deny', function() {
        expect({
          memberName: [1, 2, 3]
        }).not.toHaveEmptyArray('memberName');
        expect({
          memberName: ''
        }).not.toHaveEmptyArray('memberName');
      });
    });
    describe('when named array has no members', function() {
      it('should confirm', function() {
        expect({
          memberName: []
        }).toHaveEmptyArray('memberName');
      });
    });
  });
});

describe('toHaveEmptyObject', function() {
  beforeEach(function() {
    this.Foo = function() { };
  });
  describeToHaveX('toHaveEmptyObject', function() {
    describe('when subject IS an Object with no instance members', function() {
      beforeEach(function() {
        this.Foo.prototype = {
          b: 2
        };
      });
      it('should confirm', function() {
        expect({
          memberName: new this.Foo()
        }).toHaveEmptyObject('memberName');
        expect({
          memberName: {}
        }).toHaveEmptyObject('memberName');
      });
    });
    describe('when subject is NOT an Object with no instance members', function() {
      it('should deny', function() {
        expect({
          memberName: {
            a: 1
          }
        }).not.toHaveEmptyObject('memberName');
        expect({
          memberName: null
        }).not.toHaveNonEmptyObject('memberName');
      });
    });
  });
});

describe('toHaveEmptyString', function() {
  describeToHaveX('toHaveEmptyString', function() {
    describe('when subject IS a string with no characters', function() {
      it('should confirm', function() {
        expect({
          memberName: ''
        }).toHaveEmptyString('memberName');
      });
    });
    describe('when subject is NOT a string with no characters', function() {
      it('should deny', function() {
        expect({
          memberName: ' '
        }).not.toHaveEmptyString('memberName');
      });
    });
  });
});

describe('toHaveEvenNumber', function() {
  describeToHaveX('toHaveEvenNumber', function() {
    describe('when subject IS an even number', function() {
      it('should confirm', function() {
        expect({
          memberName: 2
        }).toHaveEvenNumber('memberName');
      });
    });
    describe('when subject is NOT an even number', function() {
      it('should deny', function() {
        expect({
          memberName: 1
        }).not.toHaveEvenNumber('memberName');
        expect({
          memberName: NaN
        }).not.toHaveEvenNumber('memberName');
      });
    });
  });
});

describe('toHaveFalse', function() {
  describeToHaveBooleanX('toHaveFalse', function() {
    describe('when primitive', function() {
      describe('when true', function() {
        it('should deny', function() {
          expect({
            memberName: true
          }).not.toHaveFalse('memberName');
        });
      });
      describe('when false', function() {
        it('should confirm', function() {
          expect({
            memberName: false
          }).toHaveFalse('memberName');
        });
      });
    });
    describe('when Boolean object', function() {
      describe('when true', function() {
        it('should deny', function() {
          expect({
            memberName: new Boolean(true)
          }).not.toHaveFalse('memberName');
        });
      });
      describe('when false', function() {
        it('should confirm', function() {
          expect({
            memberName: new Boolean(false)
          }).toHaveFalse('memberName');
        });
      });
    });
  });
});

describe('toHaveHtmlString', function() {
  describeToHaveX('toHaveHtmlString', function() {
    describe('when subject IS a string of HTML markup', function() {
      beforeEach(function() {
        this.ngMultiLine = '';
        this.ngMultiLine += '<a data-ng-href="//www.google.com" data-ng-click="launchApp($event)" target="_blank" class="ng-binding" href="//www.google.com">';
        this.ngMultiLine += '\n';
        this.ngMultiLine += '  Watch with Google TV';
        this.ngMultiLine += '\n';
        this.ngMultiLine += '</a>';
        this.ngMultiLine += '\n';
      });
      it('should confirm', function() {
        expect({
          memberName: '<element>text</element>'
        }).toHaveHtmlString('memberName');
        expect({
          memberName: '<a data-ng-href="//foo.com" data-ng-click="bar($event)">baz</a>'
        }).toHaveHtmlString('memberName');
        expect({
          memberName: '<div ng-if="foo > bar || bar < foo && baz == bar"></div>'
        }).toHaveHtmlString('memberName');
        expect({
          memberName: '<li ng-if="foo > bar || bar < foo && baz == bar">'
        }).toHaveHtmlString('memberName');
        expect({
          memberName: this.ngMultiLine
        }).toHaveHtmlString('memberName');
      });
    });
    describe('when subject is NOT a string of HTML markup', function() {
      it('should deny', function() {
        expect({
          memberName: 'div'
        }).not.toHaveHtmlString('memberName');
        expect({
          memberName: null
        }).not.toHaveHtmlString('memberName');
      });
    });
  });
});

describe('toHaveIso8601', function() {
  describeToHaveX('toHaveIso8601', function() {
    describe('when member is a Date String conforming to the ISO 8601 standard',
      function() {
        describe('when specified date is valid', function() {
          it('should confirm', function() {
            expect({
              memberName: '2013-07-08T07:29:15.863Z'
            }).toHaveIso8601('memberName');
            expect({
              memberName: '2013-07-08T07:29:15.863'
            }).toHaveIso8601('memberName');
            expect({
              memberName: '2013-07-08T07:29:15'
            }).toHaveIso8601('memberName');
            expect({
              memberName: '2013-07-08T07:29'
            }).toHaveIso8601('memberName');
            expect({
              memberName: '2013-07-08'
            }).toHaveIso8601('memberName');
          });
        });
        describe('when specified date is NOT valid', function() {
          it('should deny', function() {
            expect({
              memberName: '2013-99-12T00:00:00.000Z'
            }).not.toHaveIso8601('memberName');
            expect({
              memberName: '2013-12-99T00:00:00.000Z'
            }).not.toHaveIso8601('memberName');
            expect({
              memberName: '2013-01-01T99:00:00.000Z'
            }).not.toHaveIso8601('memberName');
            expect({
              memberName: '2013-01-01T99:99:00.000Z'
            }).not.toHaveIso8601('memberName');
            expect({
              memberName: '2013-01-01T00:00:99.000Z'
            }).not.toHaveIso8601('memberName');
          });
        });
      });
    describe('when member is a String NOT conforming to the ISO 8601 standard',
      function() {
        it('should deny', function() {
          expect({
            memberName: '2013-07-08T07:29:15.'
          }).not.toHaveIso8601('memberName');
          expect({
            memberName: '2013-07-08T07:29:'
          }).not.toHaveIso8601('memberName');
          expect({
            memberName: '2013-07-08T07:2'
          }).not.toHaveIso8601('memberName');
          expect({
            memberName: '2013-07-08T07:'
          }).not.toHaveIso8601('memberName');
          expect({
            memberName: '2013-07-08T07'
          }).not.toHaveIso8601('memberName');
          expect({
            memberName: '2013-07-08T'
          }).not.toHaveIso8601('memberName');
          expect({
            memberName: '2013-07-0'
          }).not.toHaveIso8601('memberName');
          expect({
            memberName: '2013-07-'
          }).not.toHaveIso8601('memberName');
          expect({
            memberName: '2013-07'
          }).not.toHaveIso8601('memberName');
          expect({
            memberName: '2013-0'
          }).not.toHaveIso8601('memberName');
          expect({
            memberName: '2013-'
          }).not.toHaveIso8601('memberName');
          expect({
            memberName: '2013'
          }).not.toHaveIso8601('memberName');
          expect({
            memberName: '201'
          }).not.toHaveIso8601('memberName');
          expect({
            memberName: '20'
          }).not.toHaveIso8601('memberName');
          expect({
            memberName: '2'
          }).not.toHaveIso8601('memberName');
          expect({
            memberName: ''
          }).not.toHaveIso8601('memberName');
        });
      });
  });
});

describe('toHaveJsonString', function() {
  describeToHaveX('toHaveJsonString', function() {
    describe('when subject IS a string of parseable JSON', function() {
      it('should confirm', function() {
        expect({
          memberName: '{}'
        }).toHaveJsonString('memberName');
        expect({
          memberName: '[]'
        }).toHaveJsonString('memberName');
        expect({
          memberName: '[1]'
        }).toHaveJsonString('memberName');
      });
    });
    describe('when subject is NOT a string of parseable JSON', function() {
      it('should deny', function() {
        expect({
          memberName: '[1,]'
        }).not.toHaveJsonString('memberName');
        expect({
          memberName: '<>'
        }).not.toHaveJsonString('memberName');
        expect({
          memberName: null
        }).not.toHaveJsonString('memberName');
        expect({
          memberName: ''
        }).not.toHaveJsonString('memberName');
        expect({
          memberName: _undefined
        }).not.toHaveJsonString('memberName');
      });
    });
  });
});

describe('toHaveMember', function() {
  describeToHaveX('toHaveMember', function() { });
});

describe('toHaveMethod', function() {
  describeToHaveX('toHaveMethod', function() {
    describe('when subject IS a function', function() {
      it('should confirm', function() {
        expect({
          memberName: function() { }
        }).toHaveMethod('memberName');
      });
    });
    describe('when subject is NOT a function', function() {
      it('should deny', function() {
        expect({
          memberName: /regexp/
        }).not.toHaveMethod('memberName');
      });
    });
  });
});

describe('toHaveNonEmptyArray', function() {
  describeToHaveArrayX('toHaveNonEmptyArray', function() {
    describe('when named array has no members', function() {
      it('should deny', function() {
        expect({
          memberName: []
        }).not.toHaveNonEmptyArray('memberName');
      });
    });
    describe('when named array has members', function() {
      it('should confirm', function() {
        expect({
          memberName: [1, 2, 3]
        }).toHaveNonEmptyArray('memberName');
      });
    });
  });
});

describe('toHaveNonEmptyObject', function() {
  describeToHaveX('toHaveNonEmptyObject', function() {
    beforeEach(function() {
      this.Foo = function() { };
    });
    describe('when subject IS an Object with at least one instance member', function() {
      it('should confirm', function() {
        expect({
          memberName: {
            a: 1
          }
        }).toHaveNonEmptyObject('memberName');
      });
    });
    describe('when subject is NOT an Object with at least one instance member', function() {
      beforeEach(function() {
        this.Foo.prototype = {
          b: 2
        };
      });
      it('should deny', function() {
        expect({
          memberName: new this.Foo()
        }).not.toHaveNonEmptyObject('memberName');
        expect({
          memberName: {}
        }).not.toHaveNonEmptyObject('memberName');
        expect({
          memberName: null
        }).not.toHaveNonEmptyObject('memberName');
      });
    });
  });
});

describe('toHaveNonEmptyString', function() {
  describeToHaveX('toHaveNonEmptyString', function() {
    describe('when subject IS a string with at least one character', function() {
      it('should confirm', function() {
        expect({
          memberName: ' '
        }).toHaveNonEmptyString('memberName');
      });
    });
    describe('when subject is NOT a string with at least one character', function() {
      it('should deny', function() {
        expect({
          memberName: ''
        }).not.toHaveNonEmptyString('memberName');
        expect({
          memberName: null
        }).not.toHaveNonEmptyString('memberName');
      });
    });
  });
});

describe('toHaveNumber', function() {
  describeToHaveX('toHaveNumber', function() {
    describe('when subject IS a number', function() {
      it('should confirm', function() {
        expect({
          memberName: 1
        }).toHaveNumber('memberName');
        expect({
          memberName: 1.11
        }).toHaveNumber('memberName');
        expect({
          memberName: 1e3
        }).toHaveNumber('memberName');
        expect({
          memberName: 0.11
        }).toHaveNumber('memberName');
        expect({
          memberName: -11
        }).toHaveNumber('memberName');
      });
    });
    describe('when subject is NOT a number', function() {
      it('should deny', function() {
        expect({
          memberName: '1'
        }).not.toHaveNumber('memberName');
        expect({
          memberName: NaN
        }).not.toHaveNumber('memberName');
      });
    });
  });
});

describe('toHaveNumberWithinRange', function() {
  describeToHaveX('toHaveNumberWithinRange', function() {
    describe('when subject IS a number >= floor and <= ceiling', function() {
      it('should confirm', function() {
        expect({
          memberName: 0
        }).toHaveNumberWithinRange('memberName', 0, 2);
        expect({
          memberName: 1
        }).toHaveNumberWithinRange('memberName', 0, 2);
        expect({
          memberName: 2
        }).toHaveNumberWithinRange('memberName', 0, 2);
      });
    });
    describe('when subject is NOT a number >= floor and <= ceiling', function() {
      it('should deny', function() {
        expect({
          memberName: -3
        }).not.toHaveNumberWithinRange('memberName', 0, 2);
        expect({
          memberName: -2
        }).not.toHaveNumberWithinRange('memberName', 0, 2);
        expect({
          memberName: -1
        }).not.toHaveNumberWithinRange('memberName', 0, 2);
        expect({
          memberName: 3
        }).not.toHaveNumberWithinRange('memberName', 0, 2);
        expect({
          memberName: NaN
        }).not.toHaveNumberWithinRange('memberName', 0, 2);
      });
    });
  });
});

describe('toHaveObject', function() {
  describeToHaveX('toHaveObject', function() {
    beforeEach(function() {
      this.Foo = function() { };
    });
    describe('when subject IS an Object', function() {
      it('should confirm', function() {
        expect({
          memberName: new Object()
        }).toHaveObject('memberName');
        expect({
          memberName: new this.Foo()
        }).toHaveObject('memberName');
        expect({
          memberName: {}
        }).toHaveObject('memberName');
      });
    });
    describe('when subject is NOT an Object', function() {
      it('should deny', function() {
        expect({
          memberName: null
        }).not.toHaveObject('memberName');
        expect({
          memberName: 123
        }).not.toHaveObject('memberName');
        expect({
          memberName: '[object Object]'
        }).not.toHaveObject('memberName');
      });
    });
  });
});

describe('toHaveOddNumber', function() {
  describeToHaveX('toHaveOddNumber', function() {
    describe('when subject IS an odd number', function() {
      it('should confirm', function() {
        expect({
          memberName: 1
        }).toHaveOddNumber('memberName');
      });
    });
    describe('when subject is NOT an odd number', function() {
      it('should deny', function() {
        expect({
          memberName: 2
        }).not.toHaveOddNumber('memberName');
        expect({
          memberName: NaN
        }).not.toHaveOddNumber('memberName');
      });
    });
  });
});

describe('toHaveString', function() {
  describeToHaveX('toHaveString', function() {
    describe('when subject IS a string of any length', function() {
      it('should confirm', function() {
        expect({
          memberName: ''
        }).toHaveString('memberName');
        expect({
          memberName: ' '
        }).toHaveString('memberName');
      });
    });
    describe('when subject is NOT a string of any length', function() {
      it('should deny', function() {
        expect({
          memberName: null
        }).not.toHaveString('memberName');
      });
    });
  });
});

describe('toHaveStringLongerThan', function() {
  describeToHaveX('toHaveStringLongerThan', function() {
    describe('when the subject and comparison ARE both strings', function() {
      describe('when the subject IS longer than the comparision string', function() {
        it('should confirm', function() {
          expect({
            memberName: 'abc'
          }).toHaveStringLongerThan('memberName', 'ab');
          expect({
            memberName: 'a'
          }).toHaveStringLongerThan('memberName', '');
        });
      });
      describe('when the subject is NOT longer than the comparision string', function() {
        it('should deny', function() {
          expect({
            memberName: 'ab'
          }).not.toHaveStringLongerThan('memberName', 'abc');
          expect({
            memberName: ''
          }).not.toHaveStringLongerThan('memberName', 'a');
        });
      });
    });
    describe('when the subject and comparison are NOT both strings', function() {
      it('should deny (we are asserting the relative lengths of two strings)', function() {
        expect({
          memberName: 'truthy'
        }).not.toHaveStringLongerThan('memberName', _undefined);
        expect({
          memberName: _undefined
        }).not.toHaveStringLongerThan('memberName', 'truthy');
        expect({
          memberName: ''
        }).not.toHaveStringLongerThan('memberName', _undefined);
        expect({
          memberName: _undefined
        }).not.toHaveStringLongerThan('memberName', '');
      });
    });
  });
});

describe('toHaveStringSameLengthAs', function() {
  describeToHaveX('toHaveStringSameLengthAs', function() {
    describe('when the subject and comparison ARE both strings', function() {
      describe('when the subject IS the same length as the comparision string', function() {
        it('should confirm', function() {
          expect({
            memberName: 'ab'
          }).toHaveStringSameLengthAs('memberName', 'ab');
        });
      });
      describe('when the subject is NOT the same length as the comparision string', function() {
        it('should deny', function() {
          expect({
            memberName: 'abc'
          }).not.toHaveStringSameLengthAs('memberName', 'ab');
          expect({
            memberName: 'a'
          }).not.toHaveStringSameLengthAs('memberName', '');
          expect({
            memberName: ''
          }).not.toHaveStringSameLengthAs('memberName', 'a');
        });
      });
    });
    describe('when the subject and comparison are NOT both strings', function() {
      it('should deny (we are asserting the relative lengths of two strings)', function() {
        expect({
          memberName: 'truthy'
        }).not.toHaveStringSameLengthAs('memberName', _undefined);
        expect({
          memberName: _undefined
        }).not.toHaveStringSameLengthAs('memberName', 'truthy');
        expect({
          memberName: ''
        }).not.toHaveStringSameLengthAs('memberName', _undefined);
        expect({
          memberName: _undefined
        }).not.toHaveStringSameLengthAs('memberName', '');
      });
    });
  });
});

describe('toHaveStringShorterThan', function() {
  describeToHaveX('toHaveStringShorterThan', function() {
    describe('when the subject and comparison ARE both strings', function() {
      describe('when the subject IS shorter than the comparision string', function() {
        it('should confirm', function() {
          expect({
            memberName: 'ab'
          }).toHaveStringShorterThan('memberName', 'abc');
          expect({
            memberName: ''
          }).toHaveStringShorterThan('memberName', 'a');
        });
      });
      describe('when the subject is NOT shorter than the comparision string', function() {
        it('should deny', function() {
          expect({
            memberName: 'abc'
          }).not.toHaveStringShorterThan('memberName', 'ab');
          expect({
            memberName: 'a'
          }).not.toHaveStringShorterThan('memberName', '');
        });
      });
    });
    describe('when the subject and comparison are NOT both strings', function() {
      it('should deny (we are asserting the relative lengths of two strings)', function() {
        expect({
          memberName: 'truthy'
        }).not.toHaveStringShorterThan('memberName', _undefined);
        expect({
          memberName: _undefined
        }).not.toHaveStringShorterThan('memberName', 'truthy');
        expect({
          memberName: ''
        }).not.toHaveStringShorterThan('memberName', _undefined);
        expect({
          memberName: _undefined
        }).not.toHaveStringShorterThan('memberName', '');
      });
    });
  });
});


describe('toHaveTrue', function() {
  describeToHaveBooleanX('toHaveTrue', function() {
    describe('when primitive', function() {
      describe('when true', function() {
        it('should confirm', function() {
          expect({
            memberName: true
          }).toHaveTrue('memberName');
        });
      });
      describe('when false', function() {
        it('should deny', function() {
          expect({
            memberName: false
          }).not.toHaveTrue('memberName');
        });
      });
    });
    describe('when Boolean object', function() {
      describe('when true', function() {
        it('should confirm', function() {
          expect({
            memberName: new Boolean(true)
          }).toHaveTrue('memberName');
        });
      });
      describe('when false', function() {
        it('should deny', function() {
          expect({
            memberName: new Boolean(false)
          }).not.toHaveTrue('memberName');
        });
      });
    });
  });
});

describe('toHaveWhitespaceString', function() {
  describeToHaveX('toHaveWhitespaceString', function() {
    describe('when subject IS a string containing only tabs, spaces, returns etc', function() {
      it('should confirm', function() {
        expect({
          memberName: ' '
        }).toHaveWhitespaceString('memberName');
        expect({
          memberName: ''
        }).toHaveWhitespaceString('memberName');
      });
    });
    describe('when subject is NOT a string containing only tabs, spaces, returns etc', function() {
      it('should deny', function() {
        expect({
          memberName: 'has-no-whitespace'
        }).not.toHaveWhitespaceString('memberName');
        expect({
          memberName: 'has whitespace'
        }).not.toHaveWhitespaceString('memberName');
        expect({
          memberName: null
        }).not.toHaveWhitespaceString('memberName');
      });
    });
  });
});

describe('toHaveWholeNumber', function() {
  describeToHaveX('toHaveWholeNumber', function() {
    describe('when subject IS a number with no positive decimal places', function() {
      it('should confirm', function() {
        expect({
          memberName: 1
        }).toHaveWholeNumber('memberName');
        expect({
          memberName: 0
        }).toHaveWholeNumber('memberName');
        expect({
          memberName: 0.0
        }).toHaveWholeNumber('memberName');
      });
    });
    describe('when subject is NOT a number with no positive decimal places', function() {
      it('should deny', function() {
        expect({
          memberName: NaN
        }).not.toHaveWholeNumber('memberName');
        expect({
          memberName: 1.1
        }).not.toHaveWholeNumber('memberName');
        expect({
          memberName: 0.1
        }).not.toHaveWholeNumber('memberName');
      });
    });
  });
});

describe('toImplement', function() {
  describe('when invoked', function() {
    describe('when subject IS an Object containing all of the supplied members', function() {
      it('should confirm', function() {
        expect({
          a: 1,
          b: 2
        }).toImplement({
          a: 1,
          b: 2
        });
        expect({
          a: 1,
          b: 2
        }).toImplement({
          a: 1
        });
      });
    });
    describe('when subject is NOT an Object containing all of the supplied members', function() {
      it('should deny', function() {
        expect({
          a: 1
        }).not.toImplement({
          c: 3
        });
        expect(null).not.toImplement({
          a: 1
        });
      });
    });
  });
});

describe('toStartWith', function() {
  describe('when invoked', function() {
    describe('when subject is NOT an undefined or empty string', function() {
      describe('when subject is a string whose leading characters match the expected string', function() {
        it('should confirm', function() {
          expect('jamie').toStartWith('jam');
        });
      });
      describe('when subject is a string whose leading characters DO NOT match the expected string', function() {
        it('should deny', function() {
          expect(' jamie').not.toStartWith('jam');
          expect('Jamie').not.toStartWith('jam');
        });
      });
    });
    describe('when subject IS an undefined or empty string', function() {
      it('should deny', function() {
        expect('').not.toStartWith('');
        expect(_undefined).not.toStartWith('');
        expect(_undefined).not.toStartWith('undefined');
        expect('undefined').not.toStartWith(_undefined);
      });
    });
  });
});


describe('toThrowAnyError', function() {
  describe('when supplied a function', function() {
    describe('when function errors when invoked', function() {
      beforeEach(function() {
        this.throwError = function() {
          throw new Error('wut?');
        };
        this.badReference = function() {
          return badReference.someValue;
        };
      });
      it('should confirm', function() {
        expect(this.throwError).toThrowAnyError();
        expect(this.badReference).toThrowAnyError();
      });
    });
    describe('when function does NOT error when invoked', function() {
      beforeEach(function() {
        this.noErrors = function() { };
      });
      it('should deny', function() {
        expect(this.noErrors).not.toThrowAnyError();
      });
    });
  });
});


describe('toThrowErrorOfType', function() {
  describe('when supplied a function', function() {
    describe('when function errors when invoked', function() {
      beforeEach(function() {
        this.throwError = function() {
          throw new Error('wut?');
        };
        this.badReference = function() {
          return badReference.someValue;
        };
      });
      describe('when the error is of the expected type', function() {
        it('should confirm', function() {
          expect(this.throwError).toThrowErrorOfType('Error');
          expect(this.badReference).toThrowErrorOfType('ReferenceError');
        });
      });
      describe('when the error is NOT of the expected type', function() {
        it('should confirm', function() {
          expect(this.throwError).not.toThrowErrorOfType('ReferenceError');
          expect(this.badReference).not.toThrowErrorOfType('Error');
        });
      });
    });
  });
});