xunit.ts 1.0.1 → 1.1.0

package/src/Assertions/Equal.ts

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

package/src/Assertions/False.ts

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

package/src/Assertions/InstanceOf.ts

@@ -2,27 +2,27 @@ import { AssertionError } from "assert";
 
 /**
  * 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` 
+ *
+ * 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) {
-    if (expression instanceof type) {
-        return;
-    }
+export default function InstanceOf(type: any, expression: any, message?: string) {
+	if (expression instanceof type) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || `Expected expression of type, but was ${typeof expression}`,
-        expected: type,
-        actual: typeof expression
-    })
+	throw new AssertionError({
+		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
+	});
 }