xunit.ts 1.0.2 → 1.2.0

package/src/Assertions/InstanceOf.ts

@@ -15,7 +15,7 @@ import { AssertionError } from "assert";
  * @example
  * this.assert.instanceOf(type, object);
  */
-export default function InstanceOf<T>(type: any, expression: any, message?: string) {
+export default function InstanceOf(type: any, expression: any, message?: string) {
 	if (expression instanceof type) {
 		return;
 	}
@@ -24,5 +24,5 @@ export default function InstanceOf<T>(type: any, expression: any, message?: stri
 		message: message || `Expected expression of type, but was ${typeof expression}`,
 		expected: type.name,
 		actual: typeof expression
-	})
+	});
 }

package/src/Assertions/NotEmpty.ts

@@ -2,26 +2,26 @@ import { AssertionError } from "assert";
 
 /**
  * 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) {
-    if(array.length > 0) {
-        return;
-    }
+	if (array.length > 0) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected expression to be not empty, but expression was empty',
-        expected: '(non-empty expression)',
-        actual: array
-    })
+	throw new AssertionError({
+		message: message || "Expected expression to be not empty, but expression was empty",
+		expected: "(non-empty expression)",
+		actual: array
+	});
 }

package/src/Assertions/NotEqual.ts

@@ -1,14 +1,14 @@
 import { AssertionError } from "assert";
-import equal from 'lodash.isequal';
+import equal from "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
@@ -17,13 +17,13 @@ import equal from 'lodash.isequal';
  * this.assert.notEqual(expected, actual);
  */
 export default function NotEqual(expected: any, actual: any, message?: string) {
-    if(!equal(actual, expected)) {
-        return;
-    }
+	if (!equal(actual, expected)) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected expressions to be not equal, but expressions are equal',
-        expected: expected,
-        actual: actual,
-    });
+	throw new AssertionError({
+		message: message || "Expected expressions to be not equal, but expressions are equal",
+		expected: expected,
+		actual: actual,
+	});
 }

package/src/Assertions/NotNull.ts

@@ -2,12 +2,12 @@ import { AssertionError } from "assert";
 
 /**
  * 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
  *
@@ -15,13 +15,13 @@ import { AssertionError } from "assert";
  * this.assert.notNull(expression);
  */
 export default function NotNull(expression: any, message?: string) {
-    if(expression !== null) {
-        return;
-    }
+	if (expression !== null) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected expression to be not null, but expression is null',
-        expected: '(non-null expression)',
-        actual: expression
-    });
+	throw new AssertionError({
+		message: message || "Expected expression to be not null, but expression is null",
+		expected: "(non-null expression)",
+		actual: expression
+	});
 }

package/src/Assertions/Null.ts

@@ -2,12 +2,12 @@ import { AssertionError } from "assert";
 
 /**
  * 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
  *
@@ -15,13 +15,13 @@ import { AssertionError } from "assert";
  * this.assert.null(expression);
  */
 export default function Null(expression: any, message?: string) {
-    if(expression === null) {
-        return;
-    }
+	if (expression === null) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected expression to be null, but expression is not null',
-        expected: null,
-        actual: expression
-    });
+	throw new AssertionError({
+		message: message || "Expected expression to be null, but expression is not null",
+		expected: null,
+		actual: expression
+	});
 }

package/src/Assertions/StringContains.ts

@@ -2,27 +2,27 @@ import { AssertionError } from "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);
  */
 export default function StringContains(needle: string, haystack: string | null, message?: string) {
-    if (haystack !== undefined && haystack !== null && haystack.indexOf(needle) > -1) {
-        return;
-    }
+	if (haystack !== undefined && haystack !== null && haystack.indexOf(needle) > -1) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected string containing expression, but string did not contain expression',
-        expected: needle,
-        actual: haystack
-    });
+	throw new AssertionError({
+		message: message || "Expected string containing expression, but string did not contain expression",
+		expected: needle,
+		actual: haystack
+	});
 }

package/src/Assertions/StringDoesNotContain.ts

@@ -2,27 +2,27 @@ import { AssertionError } from "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);
  */
-export default function StringDoesNotContain(needle: string, haystack: string|null, message?: string) {
-    if(haystack === undefined || haystack === null || haystack.indexOf(needle) === -1) {
-        return;
-    }
+export default function StringDoesNotContain(needle: string, haystack: string | null, message?: string) {
+	if (haystack === undefined || haystack === null || haystack.indexOf(needle) === -1) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected string not containing expression, but string did contain expression',
-        expected: needle,
-        actual: haystack
-    });
+	throw new AssertionError({
+		message: message || "Expected string not containing expression, but string did contain expression",
+		expected: needle,
+		actual: haystack
+	});
 }

package/src/Assertions/StringDoesNotEndWith.ts

@@ -2,29 +2,29 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that a string does not end with a given substring
- * 
+ *
  * @remarks
  * Passes if the final characters of `haystack` do not match `needle`
- * 
+ *
  * Fails if the final characters of `haystack` match `needle`
  *
  * @param needle the substring to find
  * @param haystack the string to search
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.stringDoesNotEndWith(needle, haystack);
  */
 export default function StringDoesNotEndWith(needle: string, haystack: string | null, message?: string) {
-    if (haystack === undefined || haystack === null
-        || haystack.indexOf(needle) === -1
-        || haystack.indexOf(needle) !== haystack.length - needle.length) {
-        return;
-    }
+	if (haystack === undefined || haystack === null
+		|| haystack.indexOf(needle) === -1
+		|| haystack.indexOf(needle) !== haystack.length - needle.length) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected string containing expression, but string did not contain expression',
-        expected: needle,
-        actual: haystack
-    });
+	throw new AssertionError({
+		message: message || "Expected string containing expression, but string did not contain expression",
+		expected: needle,
+		actual: haystack
+	});
 }

package/src/Assertions/StringDoesNotStartWith.ts

@@ -2,27 +2,27 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that a string does not begin with a given substring
- * 
+ *
  * @remarks
  * Passes if the first characters of `haystack` do not match `needle`
- * 
+ *
  * Fails if the first characters of `haystack` match `needle`
  *
  * @param needle the substring to find
  * @param haystack the string to search
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.stringDoesNotStartWith(needle, haystack);
  */
-export default function StringDoesNotStartWith(needle: string, haystack: string|null, message?: string) {
-    if(haystack === undefined || haystack === null || haystack.indexOf(needle) !== 0) {
-        return;
-    }
+export default function StringDoesNotStartWith(needle: string, haystack: string | null, message?: string) {
+	if (haystack === undefined || haystack === null || haystack.indexOf(needle) !== 0) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected string containing expression, but string did not contain expression',
-        expected: needle,
-        actual: haystack
-    });
+	throw new AssertionError({
+		message: message || "Expected string containing expression, but string did not contain expression",
+		expected: needle,
+		actual: haystack
+	});
 }

package/src/Assertions/StringEndsWith.ts

@@ -2,29 +2,29 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that a string ends with a given substring
- * 
+ *
  * @remarks
  * Passes if the final characters of `haystack` match `needle`
- * 
+ *
  * Fails if the final characters of `haystack` do not match `needle`
  *
  * @param needle the substring to find
  * @param haystack the string to search
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.stringEndsWith(needle, haystack);
  */
 export default function StringEndsWith(needle: string, haystack: string | null, message?: string) {
-    if (haystack !== undefined && haystack !== null
-        && haystack.indexOf(needle) > -1
-        && haystack.indexOf(needle) === haystack.length - needle.length) {
-        return;
-    }
+	if (haystack !== undefined && haystack !== null
+		&& haystack.indexOf(needle) > -1
+		&& haystack.indexOf(needle) === haystack.length - needle.length) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected string containing expression, but string did not contain expression',
-        expected: needle,
-        actual: haystack
-    });
+	throw new AssertionError({
+		message: message || "Expected string containing expression, but string did not contain expression",
+		expected: needle,
+		actual: haystack
+	});
 }

package/src/Assertions/StringStartsWith.ts

@@ -2,27 +2,27 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that a string begins with a given substring
- * 
+ *
  * @remarks
  * Passes if the first characters of `haystack` match `needle`
- * 
+ *
  * Fails if the first characters of `haystack` do not match `needle`
  *
  * @param needle the substring to find
  * @param haystack the string to search
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.stringStartsWith(needle, haystack);
  */
-export default function StringStartsWith(needle: string, haystack: string|null, message?: string) {
-    if(haystack !== undefined && haystack !== null && haystack.indexOf(needle) === 0) {
-        return;
-    }
+export default function StringStartsWith(needle: string, haystack: string | null, message?: string) {
+	if (haystack !== undefined && haystack !== null && haystack.indexOf(needle) === 0) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected string containing expression, but string did not contain expression',
-        expected: needle,
-        actual: haystack
-    });
+	throw new AssertionError({
+		message: message || "Expected string containing expression, but string did not contain expression",
+		expected: needle,
+		actual: haystack
+	});
 }

package/src/Assertions/Throws.ts

@@ -2,26 +2,26 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that an expression throws an error/exception
- * 
+ *
  * @remarks
  * Passes if calling `expression` throws an error/exception
- * 
+ *
  * Fails if calling `expression` does not throw an error/exception
  *
  * @param expression the expression to run
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.throws(() => expression);
  */
 export default function Throws(expression: () => any, message?: string) {
-    try {
-        expression();
-    } catch (exception) {
-        return;
-    }
+	try {
+		expression();
+	} catch (exception) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected expression to throw exception, but expression did not throw exception'
-    });
+	throw new AssertionError({
+		message: message || "Expected expression to throw exception, but expression did not throw exception"
+	});
 }

package/src/Assertions/True.ts

@@ -2,12 +2,12 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that a given expression evaluates to `true`
- * 
+ *
  * @remarks
  * Passes if `expression` evaluates to `true`
- * 
+ *
  * Fails if `expression` does not evaluate to `true`
- * 
+ *
  * @param expression the value to check
  * @param message (optional) message to display on failure
  *
@@ -15,13 +15,13 @@ import { AssertionError } from "assert";
  * this.assert.true(expression);
  */
 export default function True(expression: any, message?: string) {
-    if(expression === true) {
-        return;
-    }
+	if (expression === true) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected expression to be true, but expression is not true',
-        expected: true,
-        actual: expression
-    });
+	throw new AssertionError({
+		message: message || "Expected expression to be true, but expression is not true",
+		expected: true,
+		actual: expression
+	});
 }

package/src/Assertions/Undefined.ts

@@ -2,26 +2,26 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that a given value is equal to `undefined`
- * 
+ *
  * @remarks
  * Passes if `expression` evaluates to `undefined`
- * 
+ *
  * Fails if `expression` does not evaluate to `undefined`
- * 
+ *
  * @param expression the value to check
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.undefined(expression);
  */
 export default function Undefined(expression: any, message?: string) {
-    if(expression === undefined) {
-        return;
-    }
+	if (expression === undefined) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected expression to be undefined, but expression is not undefined',
-        expected: undefined,
-        actual: expression
-    });
+	throw new AssertionError({
+		message: message || "Expected expression to be undefined, but expression is not undefined",
+		expected: undefined,
+		actual: expression
+	});
 }

package/src/Assertions/index.ts

@@ -1,69 +1,69 @@
-import is_true from './True';
-import is_false from './False';
+import is_true from "./True";
+import is_false from "./False";
 
-import is_undefined from './Undefined';
-import is_defined from './Defined';
+import is_undefined from "./Undefined";
+import is_defined from "./Defined";
 
-import is_null from './Null';
-import not_null from './NotNull';
+import is_null from "./Null";
+import not_null from "./NotNull";
 
-import equal from './Equal';
-import not_equal from './NotEqual';
+import equal from "./Equal";
+import not_equal from "./NotEqual";
 
-import empty from './Empty';
-import not_empty from './NotEmpty';
+import empty from "./Empty";
+import not_empty from "./NotEmpty";
 
-import count from './Count';
+import count from "./Count";
 
-import contains from './Contains';
-import not_contains from './DoesNotContain';
+import contains from "./Contains";
+import not_contains from "./DoesNotContain";
 
-import string_contains from './StringContains';
-import string_not_contains from './StringDoesNotContain';
+import string_contains from "./StringContains";
+import string_not_contains from "./StringDoesNotContain";
 
-import string_starts from './StringStartsWith';
-import string_not_starts from './StringDoesNotStartWith';
+import string_starts from "./StringStartsWith";
+import string_not_starts from "./StringDoesNotStartWith";
 
-import string_ends from './StringEndsWith';
-import string_not_ends from './StringDoesNotEndWith';
+import string_ends from "./StringEndsWith";
+import string_not_ends from "./StringDoesNotEndWith";
 
-import instance_of from './InstanceOf';
+import instance_of from "./InstanceOf";
 
-import throws from './Throws';
-import does_not_throw from './DoesNotThrow';
+import throws from "./Throws";
+import does_not_throw from "./DoesNotThrow";
 
 export default new class AssertionLibrary {
-    true = is_true;
-    false = is_false;
+	true = is_true;
+	false = is_false;
 
-    undefined = is_undefined;
-    defined = is_defined;
+	undefined = is_undefined;
+	defined = is_defined;
 
-    null = is_null;
-    notNull = not_null;
+	null = is_null;
+	notNull = not_null;
 
-    equal = equal;
-    notEqual = not_equal;
+	equal = equal;
+	notEqual = not_equal;
 
-    empty = empty;
-    notEmpty = not_empty;
+	empty = empty;
+	notEmpty = not_empty;
 
-    count = count;
+	count = count;
 
-    contains = contains;
-    doesNotContain = not_contains;
+	contains = contains;
+	doesNotContain = not_contains;
 
-    stringContains = string_contains;
-    stringDoesNotContain = string_not_contains;
+	stringContains = string_contains;
+	stringDoesNotContain = string_not_contains;
 
-    stringStartsWith = string_starts;
-    stringDoesNotStartWIth = string_not_starts;
+	stringStartsWith = string_starts;
+	stringDoesNotStartWIth = string_not_starts;
 
-    stringEndsWith = string_ends;
-    stringDoesNotEndWith = string_not_ends;
+	stringEndsWith = string_ends;
+	stringDoesNotEndWith = string_not_ends;
 
-    instanceOf = instance_of;
+	instanceOf = instance_of;
 
-    throws = throws;
-    doesNotThrow = does_not_throw;
-}
+	throws = throws;
+	doesNotThrow = does_not_throw;
+};