xunit.ts 0.12.0 → 1.0.1

package/dist/src/Assertions/DoesNotThrow.js

@@ -1,9 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const assert_1 = require("assert");
+/**
+ * Asserts that an expression does not throw an error/exception
+ *
+ * @remarks
+ * Passes if calling `expression` does not throw an error/exception
+ *
+ * Fails if calling `expression` throws an error/exception
+ *
+ * @param expression the expression to run
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.doesNotThrow(() => expression);
+ */
 function DoesNotThrow(expression, message) {
     try {
         expression();
+        return;
     }
     catch (exception) {
         throw new assert_1.AssertionError({

package/dist/src/Assertions/DoesNotThrow.js.map

@@ -1 +1 @@
-{"version":3,"file":"DoesNotThrow.js","sourceRoot":"","sources":["../../../src/Assertions/DoesNotThrow.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC,SAAwB,YAAY,CAAC,UAAqB,EAAE,OAAgB;IACxE,IAAI;QACA,UAAU,EAAE,CAAC;KAChB;IAAC,OAAO,SAAS,EAAE;QAChB,MAAM,IAAI,uBAAc,CAAC;YACrB,OAAO,EAAE,OAAO,IAAI,gFAAgF;YACpG,QAAQ,EAAE,gBAAgB;YAC1B,MAAM,EAAE,SAAS;SACpB,CAAC,CAAC;KACN;AACL,CAAC;AAVD,+BAUC"}
+{"version":3,"file":"DoesNotThrow.js","sourceRoot":"","sources":["../../../src/Assertions/DoesNotThrow.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC;;;;;;;;;;;;;GAaG;AACH,SAAwB,YAAY,CAAC,UAAqB,EAAE,OAAgB;IACxE,IAAI;QACA,UAAU,EAAE,CAAC;QACb,OAAO;KACV;IAAC,OAAO,SAAS,EAAE;QAChB,MAAM,IAAI,uBAAc,CAAC;YACrB,OAAO,EAAE,OAAO,IAAI,gFAAgF;YACpG,QAAQ,EAAE,gBAAgB;YAC1B,MAAM,EAAE,SAAS;SACpB,CAAC,CAAC;KACN;AACL,CAAC;AAXD,+BAWC"}

package/dist/src/Assertions/Empty.d.ts

@@ -1,2 +1,16 @@
-export default function Empty(value: any, message?: string): void;
+/**
+ * Asserts that an array is empty
+ *
+ * @remarks
+ * Passes if `array` contains zero elements
+ *
+ * Fails if `array` contains any elements
+ *
+ * @param array the array to check
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.empty(array);
+ */
+export default function Empty(array: ReadonlyArray<any>, message?: string): void;
 //# sourceMappingURL=Empty.d.ts.map

package/dist/src/Assertions/Empty.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Empty.d.ts","sourceRoot":"","sources":["../../../src/Assertions/Empty.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,KAAK,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,QAUzD"}
+{"version":3,"file":"Empty.d.ts","sourceRoot":"","sources":["../../../src/Assertions/Empty.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,OAAO,UAAU,KAAK,CAAC,KAAK,EAAE,aAAa,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,QAUxE"}

package/dist/src/Assertions/Empty.js

@@ -1,14 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const assert_1 = require("assert");
-function Empty(value, message) {
-    if (value.length === 0) {
+/**
+ * Asserts that an array is empty
+ *
+ * @remarks
+ * Passes if `array` contains zero elements
+ *
+ * Fails if `array` contains any elements
+ *
+ * @param array the array to check
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.empty(array);
+ */
+function Empty(array, message) {
+    if (array.length === 0) {
         return;
     }
     throw new assert_1.AssertionError({
         message: message || 'Expected expression to be empty, but expression was not empty',
         expected: [],
-        actual: value
+        actual: array
     });
 }
 exports.default = Empty;

package/dist/src/Assertions/Empty.js.map

@@ -1 +1 @@
-{"version":3,"file":"Empty.js","sourceRoot":"","sources":["../../../src/Assertions/Empty.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC,SAAwB,KAAK,CAAC,KAAU,EAAE,OAAgB;IACtD,IAAG,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;QACnB,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,+DAA+D;QACnF,QAAQ,EAAE,EAAE;QACZ,MAAM,EAAE,KAAK;KAChB,CAAC,CAAA;AACN,CAAC;AAVD,wBAUC"}
+{"version":3,"file":"Empty.js","sourceRoot":"","sources":["../../../src/Assertions/Empty.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC;;;;;;;;;;;;;GAaG;AACH,SAAwB,KAAK,CAAC,KAAyB,EAAE,OAAgB;IACrE,IAAG,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;QACnB,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,+DAA+D;QACnF,QAAQ,EAAE,EAAE;QACZ,MAAM,EAAE,KAAK;KAChB,CAAC,CAAA;AACN,CAAC;AAVD,wBAUC"}

package/dist/src/Assertions/Equal.d.ts

@@ -1,2 +1,17 @@
+/**
+ * Asserts that two values are equal
+ *
+ * @remarks
+ * Passes if `actual` and `expected` evaluate to equal values
+ *
+ * Fails if `actual` and `expected` do not evaluate to equal values
+ *
+ * @param expected the expected value
+ * @param actual the actual value
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.equal(expected, actual);
+ */
 export default function Equal(expected: any, actual: any, message?: string): void;
 //# sourceMappingURL=Equal.d.ts.map

package/dist/src/Assertions/Equal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Equal.d.ts","sourceRoot":"","sources":["../../../src/Assertions/Equal.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO,UAAU,KAAK,CAAC,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,QAUzE"}
+{"version":3,"file":"Equal.d.ts","sourceRoot":"","sources":["../../../src/Assertions/Equal.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,UAAU,KAAK,CAAC,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,QAUzE"}

package/dist/src/Assertions/Equal.js

@@ -5,8 +5,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const assert_1 = require("assert");
 const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
+/**
+ * Asserts that two values are equal
+ *
+ * @remarks
+ * Passes if `actual` and `expected` evaluate to equal values
+ *
+ * Fails if `actual` and `expected` do not evaluate to equal values
+ *
+ * @param expected the expected value
+ * @param actual the actual value
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.equal(expected, actual);
+ */
 function Equal(expected, actual, message) {
-    if (lodash_isequal_1.default(actual, expected)) {
+    if ((0, lodash_isequal_1.default)(actual, expected)) {
         return;
     }
     throw new assert_1.AssertionError({

package/dist/src/Assertions/Equal.js.map

@@ -1 +1 @@
-{"version":3,"file":"Equal.js","sourceRoot":"","sources":["../../../src/Assertions/Equal.ts"],"names":[],"mappings":";;;;;AAAA,mCAAwC;AACxC,oEAAmC;AAEnC,SAAwB,KAAK,CAAC,QAAa,EAAE,MAAW,EAAE,OAAgB;IACtE,IAAG,wBAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE;QACxB,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,iEAAiE;QACrF,QAAQ,EAAE,QAAQ;QAClB,MAAM,EAAE,MAAM;KACjB,CAAC,CAAC;AACP,CAAC;AAVD,wBAUC"}
+{"version":3,"file":"Equal.js","sourceRoot":"","sources":["../../../src/Assertions/Equal.ts"],"names":[],"mappings":";;;;;AAAA,mCAAwC;AACxC,oEAAmC;AAEnC;;;;;;;;;;;;;;GAcG;AACH,SAAwB,KAAK,CAAC,QAAa,EAAE,MAAW,EAAE,OAAgB;IACtE,IAAG,IAAA,wBAAK,EAAC,MAAM,EAAE,QAAQ,CAAC,EAAE;QACxB,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,iEAAiE;QACrF,QAAQ,EAAE,QAAQ;QAClB,MAAM,EAAE,MAAM;KACjB,CAAC,CAAC;AACP,CAAC;AAVD,wBAUC"}

package/dist/src/Assertions/False.d.ts

@@ -1,2 +1,16 @@
-export default function False(value: any, message?: string): void;
+/**
+ * Asserts that a given value is equal to `false`
+ *
+ * @remarks
+ * Passes if `expression` evaluates to `false`
+ *
+ * Fails if `expression` does not evaluate to `false`
+ *
+ * @param expression the value to check
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.false(expression);
+ */
+export default function False(expression: any, message?: string): void;
 //# sourceMappingURL=False.d.ts.map

package/dist/src/Assertions/False.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"False.d.ts","sourceRoot":"","sources":["../../../src/Assertions/False.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,KAAK,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,QAUzD"}
+{"version":3,"file":"False.d.ts","sourceRoot":"","sources":["../../../src/Assertions/False.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,OAAO,UAAU,KAAK,CAAC,UAAU,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,QAU9D"}

package/dist/src/Assertions/False.js

@@ -1,14 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const assert_1 = require("assert");
-function False(value, message) {
-    if (value === false) {
+/**
+ * Asserts that a given value is equal to `false`
+ *
+ * @remarks
+ * Passes if `expression` evaluates to `false`
+ *
+ * Fails if `expression` does not evaluate to `false`
+ *
+ * @param expression the value to check
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.false(expression);
+ */
+function False(expression, message) {
+    if (expression === false) {
         return;
     }
     throw new assert_1.AssertionError({
         message: message || 'Expected expression to be false, but expression is not false',
         expected: false,
-        actual: value
+        actual: expression
     });
 }
 exports.default = False;

package/dist/src/Assertions/False.js.map

@@ -1 +1 @@
-{"version":3,"file":"False.js","sourceRoot":"","sources":["../../../src/Assertions/False.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC,SAAwB,KAAK,CAAC,KAAU,EAAE,OAAgB;IACtD,IAAG,KAAK,KAAK,KAAK,EAAE;QAChB,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,8DAA8D;QAClF,QAAQ,EAAE,KAAK;QACf,MAAM,EAAE,KAAK;KAChB,CAAC,CAAC;AACP,CAAC;AAVD,wBAUC"}
+{"version":3,"file":"False.js","sourceRoot":"","sources":["../../../src/Assertions/False.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC;;;;;;;;;;;;;GAaG;AACH,SAAwB,KAAK,CAAC,UAAe,EAAE,OAAgB;IAC3D,IAAG,UAAU,KAAK,KAAK,EAAE;QACrB,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,8DAA8D;QAClF,QAAQ,EAAE,KAAK;QACf,MAAM,EAAE,UAAU;KACrB,CAAC,CAAC;AACP,CAAC;AAVD,wBAUC"}

package/dist/src/Assertions/InstanceOf.d.ts

@@ -1,2 +1,17 @@
-export default function InstanceOf<T>(type: any, value: any, message?: string): void;
+/**
+ * Asserts that a value is an instance of a certain type
+ *
+ * @remarks
+ * Passes if `object`'s type matches `type`
+ *
+ * Fails if `object`'s type does not match `type`
+ *
+ * @param type the expected type of the value
+ * @param expression the value to check
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.instanceOf(type, object);
+ */
+export default function InstanceOf<T>(type: any, expression: any, message?: string): void;
 //# sourceMappingURL=InstanceOf.d.ts.map

package/dist/src/Assertions/InstanceOf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InstanceOf.d.ts","sourceRoot":"","sources":["../../../src/Assertions/InstanceOf.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,QAU5E"}
+{"version":3,"file":"InstanceOf.d.ts","sourceRoot":"","sources":["../../../src/Assertions/InstanceOf.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,QAUjF"}

package/dist/src/Assertions/InstanceOf.js

@@ -1,14 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const assert_1 = require("assert");
-function InstanceOf(type, value, message) {
-    if (value instanceof type) {
+/**
+ * Asserts that a value is an instance of a certain type
+ *
+ * @remarks
+ * Passes if `object`'s type matches `type`
+ *
+ * Fails if `object`'s type does not match `type`
+ *
+ * @param type the expected type of the value
+ * @param expression the value to check
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.instanceOf(type, object);
+ */
+function InstanceOf(type, expression, message) {
+    if (expression instanceof type) {
         return;
     }
     throw new assert_1.AssertionError({
-        message: message || `Expected expression of type, but was ${typeof value}`,
+        message: message || `Expected expression of type, but was ${typeof expression}`,
         expected: type,
-        actual: typeof value
+        actual: typeof expression
     });
 }
 exports.default = InstanceOf;

package/dist/src/Assertions/InstanceOf.js.map

@@ -1 +1 @@
-{"version":3,"file":"InstanceOf.js","sourceRoot":"","sources":["../../../src/Assertions/InstanceOf.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC,SAAwB,UAAU,CAAI,IAAS,EAAE,KAAU,EAAE,OAAgB;IACzE,IAAI,KAAK,YAAY,IAAI,EAAE;QACvB,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,wCAAwC,OAAO,KAAK,EAAE;QAC1E,QAAQ,EAAE,IAAI;QACd,MAAM,EAAE,OAAO,KAAK;KACvB,CAAC,CAAA;AACN,CAAC;AAVD,6BAUC"}
+{"version":3,"file":"InstanceOf.js","sourceRoot":"","sources":["../../../src/Assertions/InstanceOf.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC;;;;;;;;;;;;;;GAcG;AACH,SAAwB,UAAU,CAAI,IAAS,EAAE,UAAe,EAAE,OAAgB;IAC9E,IAAI,UAAU,YAAY,IAAI,EAAE;QAC5B,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,wCAAwC,OAAO,UAAU,EAAE;QAC/E,QAAQ,EAAE,IAAI;QACd,MAAM,EAAE,OAAO,UAAU;KAC5B,CAAC,CAAA;AACN,CAAC;AAVD,6BAUC"}

package/dist/src/Assertions/NotEmpty.d.ts

@@ -1,2 +1,16 @@
-export default function NotEmpty(value: any, message?: string): void;
+/**
+ * Asserts that an array is not empty
+ *
+ * @remarks
+ * Passes if `array` contains any elements
+ *
+ * Fails if `array` contains zero elements
+ *
+ * @param array the array to check
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.notEmpty(array);
+ */
+export default function NotEmpty(array: ReadonlyArray<any>, message?: string): void;
 //# sourceMappingURL=NotEmpty.d.ts.map

package/dist/src/Assertions/NotEmpty.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NotEmpty.d.ts","sourceRoot":"","sources":["../../../src/Assertions/NotEmpty.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,QAU5D"}
+{"version":3,"file":"NotEmpty.d.ts","sourceRoot":"","sources":["../../../src/Assertions/NotEmpty.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,QAU3E"}

package/dist/src/Assertions/NotEmpty.js

@@ -1,14 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const assert_1 = require("assert");
-function NotEmpty(value, message) {
-    if (value.length > 0) {
+/**
+ * Asserts that an array is not empty
+ *
+ * @remarks
+ * Passes if `array` contains any elements
+ *
+ * Fails if `array` contains zero elements
+ *
+ * @param array the array to check
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.notEmpty(array);
+ */
+function NotEmpty(array, message) {
+    if (array.length > 0) {
         return;
     }
     throw new assert_1.AssertionError({
         message: message || 'Expected expression to be not empty, but expression was empty',
         expected: '(non-empty expression)',
-        actual: value
+        actual: array
     });
 }
 exports.default = NotEmpty;

package/dist/src/Assertions/NotEmpty.js.map

@@ -1 +1 @@
-{"version":3,"file":"NotEmpty.js","sourceRoot":"","sources":["../../../src/Assertions/NotEmpty.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC,SAAwB,QAAQ,CAAC,KAAU,EAAE,OAAgB;IACzD,IAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;QACjB,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,+DAA+D;QACnF,QAAQ,EAAE,wBAAwB;QAClC,MAAM,EAAE,KAAK;KAChB,CAAC,CAAA;AACN,CAAC;AAVD,2BAUC"}
+{"version":3,"file":"NotEmpty.js","sourceRoot":"","sources":["../../../src/Assertions/NotEmpty.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC;;;;;;;;;;;;;GAaG;AACH,SAAwB,QAAQ,CAAC,KAAyB,EAAE,OAAgB;IACxE,IAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;QACjB,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,+DAA+D;QACnF,QAAQ,EAAE,wBAAwB;QAClC,MAAM,EAAE,KAAK;KAChB,CAAC,CAAA;AACN,CAAC;AAVD,2BAUC"}

package/dist/src/Assertions/NotEqual.d.ts

@@ -1,2 +1,17 @@
+/**
+ * Asserts that two values are not equal
+ *
+ * @remarks
+ * Passes if `actual` and `expected` do not evaluate to equal values
+ *
+ * Fails if `actual` and `expected` evaluate to equal values
+ *
+ * @param expected the expected value
+ * @param actual the actual value
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.notEqual(expected, actual);
+ */
 export default function NotEqual(expected: any, actual: any, message?: string): void;
 //# sourceMappingURL=NotEqual.d.ts.map

package/dist/src/Assertions/NotEqual.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NotEqual.d.ts","sourceRoot":"","sources":["../../../src/Assertions/NotEqual.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,QAU5E"}
+{"version":3,"file":"NotEqual.d.ts","sourceRoot":"","sources":["../../../src/Assertions/NotEqual.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,QAU5E"}

package/dist/src/Assertions/NotEqual.js

@@ -1,8 +1,27 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const assert_1 = require("assert");
+const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
+/**
+ * Asserts that two values are not equal
+ *
+ * @remarks
+ * Passes if `actual` and `expected` do not evaluate to equal values
+ *
+ * Fails if `actual` and `expected` evaluate to equal values
+ *
+ * @param expected the expected value
+ * @param actual the actual value
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.notEqual(expected, actual);
+ */
 function NotEqual(expected, actual, message) {
-    if (actual !== expected) {
+    if (!(0, lodash_isequal_1.default)(actual, expected)) {
         return;
     }
     throw new assert_1.AssertionError({

package/dist/src/Assertions/NotEqual.js.map

@@ -1 +1 @@
-{"version":3,"file":"NotEqual.js","sourceRoot":"","sources":["../../../src/Assertions/NotEqual.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC,SAAwB,QAAQ,CAAC,QAAa,EAAE,MAAW,EAAE,OAAgB;IACzE,IAAG,MAAM,KAAK,QAAQ,EAAE;QACpB,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,iEAAiE;QACrF,QAAQ,EAAE,QAAQ;QAClB,MAAM,EAAE,MAAM;KACjB,CAAC,CAAC;AACP,CAAC;AAVD,2BAUC"}
+{"version":3,"file":"NotEqual.js","sourceRoot":"","sources":["../../../src/Assertions/NotEqual.ts"],"names":[],"mappings":";;;;;AAAA,mCAAwC;AACxC,oEAAmC;AAEnC;;;;;;;;;;;;;;GAcG;AACH,SAAwB,QAAQ,CAAC,QAAa,EAAE,MAAW,EAAE,OAAgB;IACzE,IAAG,CAAC,IAAA,wBAAK,EAAC,MAAM,EAAE,QAAQ,CAAC,EAAE;QACzB,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,iEAAiE;QACrF,QAAQ,EAAE,QAAQ;QAClB,MAAM,EAAE,MAAM;KACjB,CAAC,CAAC;AACP,CAAC;AAVD,2BAUC"}

package/dist/src/Assertions/NotNull.d.ts

@@ -1,2 +1,16 @@
-export default function NotNull(value: any, message?: string): void;
+/**
+ * Asserts that a value is not `null`
+ *
+ * @remarks
+ * Passes if `expression` does not evaluate to `null`
+ *
+ * Fails if `expression` evaluates to `null`
+ *
+ * @param expression the value to check
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.notNull(expression);
+ */
+export default function NotNull(expression: any, message?: string): void;
 //# sourceMappingURL=NotNull.d.ts.map

package/dist/src/Assertions/NotNull.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NotNull.d.ts","sourceRoot":"","sources":["../../../src/Assertions/NotNull.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,OAAO,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,QAU3D"}
+{"version":3,"file":"NotNull.d.ts","sourceRoot":"","sources":["../../../src/Assertions/NotNull.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,OAAO,UAAU,OAAO,CAAC,UAAU,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,QAUhE"}

package/dist/src/Assertions/NotNull.js

@@ -1,14 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const assert_1 = require("assert");
-function NotNull(value, message) {
-    if (value !== null) {
+/**
+ * Asserts that a value is not `null`
+ *
+ * @remarks
+ * Passes if `expression` does not evaluate to `null`
+ *
+ * Fails if `expression` evaluates to `null`
+ *
+ * @param expression the value to check
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.notNull(expression);
+ */
+function NotNull(expression, message) {
+    if (expression !== null) {
         return;
     }
     throw new assert_1.AssertionError({
         message: message || 'Expected expression to be not null, but expression is null',
         expected: '(non-null expression)',
-        actual: value
+        actual: expression
     });
 }
 exports.default = NotNull;

package/dist/src/Assertions/NotNull.js.map

@@ -1 +1 @@
-{"version":3,"file":"NotNull.js","sourceRoot":"","sources":["../../../src/Assertions/NotNull.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC,SAAwB,OAAO,CAAC,KAAU,EAAE,OAAgB;IACxD,IAAG,KAAK,KAAK,IAAI,EAAE;QACf,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,4DAA4D;QAChF,QAAQ,EAAE,uBAAuB;QACjC,MAAM,EAAE,KAAK;KAChB,CAAC,CAAC;AACP,CAAC;AAVD,0BAUC"}
+{"version":3,"file":"NotNull.js","sourceRoot":"","sources":["../../../src/Assertions/NotNull.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC;;;;;;;;;;;;;GAaG;AACH,SAAwB,OAAO,CAAC,UAAe,EAAE,OAAgB;IAC7D,IAAG,UAAU,KAAK,IAAI,EAAE;QACpB,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,4DAA4D;QAChF,QAAQ,EAAE,uBAAuB;QACjC,MAAM,EAAE,UAAU;KACrB,CAAC,CAAC;AACP,CAAC;AAVD,0BAUC"}

package/dist/src/Assertions/Null.d.ts

@@ -1,2 +1,16 @@
-export default function Null(value: any, message?: string): void;
+/**
+ * Asserts that a value is `null`
+ *
+ * @remarks
+ * Passes if `expression` evaluates to `null`
+ *
+ * Fails if `expression` does not evaluate to `null`
+ *
+ * @param expression the value to check
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.null(expression);
+ */
+export default function Null(expression: any, message?: string): void;
 //# sourceMappingURL=Null.d.ts.map

package/dist/src/Assertions/Null.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Null.d.ts","sourceRoot":"","sources":["../../../src/Assertions/Null.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,QAUxD"}
+{"version":3,"file":"Null.d.ts","sourceRoot":"","sources":["../../../src/Assertions/Null.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,OAAO,UAAU,IAAI,CAAC,UAAU,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,QAU7D"}

package/dist/src/Assertions/Null.js

@@ -1,14 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const assert_1 = require("assert");
-function Null(value, message) {
-    if (value === null) {
+/**
+ * Asserts that a value is `null`
+ *
+ * @remarks
+ * Passes if `expression` evaluates to `null`
+ *
+ * Fails if `expression` does not evaluate to `null`
+ *
+ * @param expression the value to check
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.null(expression);
+ */
+function Null(expression, message) {
+    if (expression === null) {
         return;
     }
     throw new assert_1.AssertionError({
         message: message || 'Expected expression to be null, but expression is not null',
         expected: null,
-        actual: value
+        actual: expression
     });
 }
 exports.default = Null;

package/dist/src/Assertions/Null.js.map

@@ -1 +1 @@
-{"version":3,"file":"Null.js","sourceRoot":"","sources":["../../../src/Assertions/Null.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC,SAAwB,IAAI,CAAC,KAAU,EAAE,OAAgB;IACrD,IAAG,KAAK,KAAK,IAAI,EAAE;QACf,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,4DAA4D;QAChF,QAAQ,EAAE,IAAI;QACd,MAAM,EAAE,KAAK;KAChB,CAAC,CAAC;AACP,CAAC;AAVD,uBAUC"}
+{"version":3,"file":"Null.js","sourceRoot":"","sources":["../../../src/Assertions/Null.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC;;;;;;;;;;;;;GAaG;AACH,SAAwB,IAAI,CAAC,UAAe,EAAE,OAAgB;IAC1D,IAAG,UAAU,KAAK,IAAI,EAAE;QACpB,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,4DAA4D;QAChF,QAAQ,EAAE,IAAI;QACd,MAAM,EAAE,UAAU;KACrB,CAAC,CAAC;AACP,CAAC;AAVD,uBAUC"}

package/dist/src/Assertions/StringContains.d.ts

@@ -1,2 +1,17 @@
+/**
+ * Asserts that a string contains a given substring
+ *
+ * @remarks
+ * Passes if `needle` is a substring of `haystack`
+ *
+ * Fails if `needle` is not a substring of `haystack`
+ *
+ * @param needle the substring to find
+ * @param haystack the string to search
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.stringContains(needle, haystack);
+ */
 export default function StringContains(needle: string, haystack: string | null, message?: string): void;
 //# sourceMappingURL=StringContains.d.ts.map

package/dist/src/Assertions/StringContains.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StringContains.d.ts","sourceRoot":"","sources":["../../../src/Assertions/StringContains.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAC,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,QAU7F"}
+{"version":3,"file":"StringContains.d.ts","sourceRoot":"","sources":["../../../src/Assertions/StringContains.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,QAU/F"}

package/dist/src/Assertions/StringContains.js

@@ -1,8 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const assert_1 = require("assert");
+/**
+ * Asserts that a string contains a given substring
+ *
+ * @remarks
+ * Passes if `needle` is a substring of `haystack`
+ *
+ * Fails if `needle` is not a substring of `haystack`
+ *
+ * @param needle the substring to find
+ * @param haystack the string to search
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.stringContains(needle, haystack);
+ */
 function StringContains(needle, haystack, message) {
-    if (haystack !== undefined && haystack !== null && haystack.indexOf(needle) !== -1) {
+    if (haystack !== undefined && haystack !== null && haystack.indexOf(needle) > -1) {
         return;
     }
     throw new assert_1.AssertionError({

package/dist/src/Assertions/StringContains.js.map

@@ -1 +1 @@
-{"version":3,"file":"StringContains.js","sourceRoot":"","sources":["../../../src/Assertions/StringContains.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC,SAAwB,cAAc,CAAC,MAAc,EAAE,QAAqB,EAAE,OAAgB;IAC1F,IAAG,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,IAAI,IAAI,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE;QAC/E,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,8EAA8E;QAClG,QAAQ,EAAE,MAAM;QAChB,MAAM,EAAE,QAAQ;KACnB,CAAC,CAAC;AACP,CAAC;AAVD,iCAUC"}
+{"version":3,"file":"StringContains.js","sourceRoot":"","sources":["../../../src/Assertions/StringContains.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC;;;;;;;;;;;;;;GAcG;AACH,SAAwB,cAAc,CAAC,MAAc,EAAE,QAAuB,EAAE,OAAgB;IAC5F,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,IAAI,IAAI,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE;QAC9E,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,8EAA8E;QAClG,QAAQ,EAAE,MAAM;QAChB,MAAM,EAAE,QAAQ;KACnB,CAAC,CAAC;AACP,CAAC;AAVD,iCAUC"}

package/dist/src/Assertions/StringDoesNotContain.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Asserts that a string does not contain a given substring
+ *
+ * @remarks
+ * Passes if `needle` is not a substring of `haystack`
+ *
+ * Fails if `needle` is a substring of `haystack`
+ *
+ * @param needle the substring to find
+ * @param haystack the string to search
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.stringDoesNotContain(needle, haystack);
+ */
+export default function StringDoesNotContain(needle: string, haystack: string | null, message?: string): void;
+//# sourceMappingURL=StringDoesNotContain.d.ts.map

package/dist/src/Assertions/StringDoesNotContain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringDoesNotContain.d.ts","sourceRoot":"","sources":["../../../src/Assertions/StringDoesNotContain.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAC,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,QAUnG"}

package/dist/src/Assertions/StringDoesNotContain.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("assert");
+/**
+ * Asserts that a string does not contain a given substring
+ *
+ * @remarks
+ * Passes if `needle` is not a substring of `haystack`
+ *
+ * Fails if `needle` is a substring of `haystack`
+ *
+ * @param needle the substring to find
+ * @param haystack the string to search
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.stringDoesNotContain(needle, haystack);
+ */
+function StringDoesNotContain(needle, haystack, message) {
+    if (haystack === undefined || haystack === null || haystack.indexOf(needle) === -1) {
+        return;
+    }
+    throw new assert_1.AssertionError({
+        message: message || 'Expected string not containing expression, but string did contain expression',
+        expected: needle,
+        actual: haystack
+    });
+}
+exports.default = StringDoesNotContain;
+//# sourceMappingURL=StringDoesNotContain.js.map

package/dist/src/Assertions/StringDoesNotContain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringDoesNotContain.js","sourceRoot":"","sources":["../../../src/Assertions/StringDoesNotContain.ts"],"names":[],"mappings":";;AAAA,mCAAwC;AAExC;;;;;;;;;;;;;;GAcG;AACH,SAAwB,oBAAoB,CAAC,MAAc,EAAE,QAAqB,EAAE,OAAgB;IAChG,IAAG,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,IAAI,IAAI,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE;QAC/E,OAAO;KACV;IAED,MAAM,IAAI,uBAAc,CAAC;QACrB,OAAO,EAAE,OAAO,IAAI,8EAA8E;QAClG,QAAQ,EAAE,MAAM;QAChB,MAAM,EAAE,QAAQ;KACnB,CAAC,CAAC;AACP,CAAC;AAVD,uCAUC"}