org.eclipse.n4js.mangelhaft.assert/src-gen/org/eclipse/n4js/mangelhaft/assert/Assert.js

An assert library used with the Mangelhaft testing framework.

// Generated by N4JS transpiler; for copyright see original N4JS source file.

import 'n4js-runtime'
import {AssertionError} from './AssertionError.js'
import {deepEqual} from './DeepEqual.js'
import {PreconditionNotMet} from '../precondition/PreconditionNotMet.js'

function getTypeName(val) {
	if (typeof val === "object") {
		let ctor = (val).constructor;
		let n4type = ctor.n4type;
		if (n4type) {
			return n4type.fqn;
		}
	}
	return String(val);
}
export const DEFAULT_TIMEOUT = 1000;
export const DEFAULT_POLLING_INTERVAL = 50;
function isUndefinedOrNull(value) {
	return value === null || value === undefined;
}
function isArguments(object) {
	return Object.getPrototypeOf({}).toString.call(object) == '[object Arguments]';
}
function expectedException(actual, expected) {
	if (typeof expected === "string") {
		return ((typeof actual) === expected);
	}
	if (Object.getPrototypeOf({}).toString.call(expected) == '[object RegExp]') {
		return (expected).test((actual).toString());
	} else if (actual instanceof expected) {
		return true;
	}
	return false;
}
export class Assert extends N4Object {
	static rethrowIfSpecialError(error, expected) {
		let objError, ctor;
		if (error !== null && typeof error === "object") {
			objError = error;
			ctor = objError.constructor;
			if (ctor !== expected && this.RETHROWN_SPECIAL_ERROR_TYPES.indexOf(ctor) !== -1) {
				throw error;
			}
		}
	}
	static fail_(actual, expected, message, operator, stackStartFunction) {
		let obj = this, fail_ = obj["fail_"], error = new AssertionError({
			message: message,
			actual: actual,
			expected: expected,
			operator: operator,
			stackStartFunction: fail_
		});
		throw error;
	}
	static fail(message, error) {
		this.fail_(error, null, message, null);
	}
	static ok(value, message) {
		if (!!!value) {
			this.fail_(value, true, message, '==');
		}
	}
	static equal(actual, expected, message) {
		if (actual != expected) {
			this.fail_(actual, expected, message, '==');
		}
	}
	static greaterThan(actual, expected, message) {
		if (!(actual > expected)) {
			this.fail_(actual, expected, message, '>');
		}
	}
	static lessThan(actual, expected, message) {
		if (!(actual < expected)) {
			this.fail_(actual, expected, message, '<');
		}
	}
	static greaterThanOrEqual(actual, expected, message) {
		if (!(actual >= expected)) {
			this.fail_(actual, expected, message, '>');
		}
	}
	static lessThanOrEqual(actual, expected, message) {
		if (!(actual <= expected)) {
			this.fail_(actual, expected, message, '<');
		}
	}
	static isNull(actual, message) {
		if (actual !== null) {
			this.fail_(actual, null, message, "=== null");
		}
	}
	static isUndefined(actual, message) {
		let undef;
		if (actual !== undef) {
			this.fail_(actual, null, message, "=== undefined");
		}
	}
	static isNotNull(actual, message) {
		if (actual === null) {
			this.fail_(actual, null, message, "!== null");
		}
	}
	static isNotUndefined(actual, message) {
		let undef;
		if (actual === undef) {
			this.fail_(actual, null, message, "!== undefined");
		}
	}
	static isNullOrUndefined(actual, message) {
		let undef;
		if (!(actual === null || actual === undef)) {
			this.fail_(actual, null, message, "=== null || undefined");
		}
	}
	static isNotNullOrUndefined(actual, message) {
		if ((actual === null || actual === undefined)) {
			this.fail_(actual, null, message, "!== null || undefined");
		}
	}
	static notEqual(actual, expected, message) {
		if (actual == expected) {
			this.fail_(actual, expected, message, '!=');
		}
	}
	static deepEqual(actual, expected, message, ignorePrototype) {
		if (!deepEqual(actual, expected, ignorePrototype)) {
			try {
				message += "\n " + JSON.stringify({
					actual: actual,
					expected: expected
				}, null, "    ");
			} catch(err) {
				message += "\n unable to calculate diff";
			}
			this.fail_(actual, expected, message, 'deepEqual');
		}
	}
	static notDeepEqual(actual, expected, message, ignorePrototype) {
		if (deepEqual(actual, expected, ignorePrototype)) {
			this.fail_(actual, expected, message, 'NotDeepEqual');
		}
	}
	static strictEqual(actual, expected, message) {
		if (!(actual === expected)) {
			this.fail_(actual, expected, message, '===');
		}
	}
	static notStrictEqual(actual, expected, message) {
		if (!(actual !== expected)) {
			this.fail_(actual, expected, message, '!==');
		}
	}
	static isTrue(actual, message) {
		if (!(!!actual)) {
			this.fail_(actual, true, message, "== true");
		}
	}
	static isFalse(actual, message) {
		if (!!actual) {
			this.fail_(actual, true, message, "!== true");
		}
	}
	static isInstanceOf(actual, expected, message) {
		if (!(actual instanceof expected)) {
			let actualName = getTypeName(actual), expectedName = getTypeName(expected);
			this.fail_(actualName, expectedName, message, "instanceof");
		}
	}
	static isNotInstanceOf(actual, expected, message) {
		if (actual instanceof expected) {
			let actualName = getTypeName(actual), expectedName = getTypeName(expected);
			this.fail_(actualName, expectedName, message, "not instanceof");
		}
	}
	static throws(testFunction, error, message) {
		let actual, threw = false;
		try {
			testFunction();
		} catch(e) {
			threw = true;
			actual = e;
		}
		if (!threw) {
			this.fail_(null, null, message, "Did not throw any exception");
		}
		return this.thrownCheck(true, actual, error, message, "throws");
	}
	static doesNotThrow(testFunction, error, message) {
		let actual, threw = false;
		try {
			testFunction();
		} catch(e) {
			threw = true;
			actual = e;
			this.rethrowIfSpecialError(actual, error);
		}
		if (threw) {
			this.fail_(actual, null, message, "does not throw");
		}
	}
	static async throwsAsync(testFunction, expectedErrorType, message) {
		let actual, threw = false;
		try {
			await Promise.resolve(testFunction());
		} catch(e) {
			threw = true;
			actual = e;
		}
		if (!threw) {
			this.fail_(null, null, message, "Did not throw any exception");
		}
		return this.thrownCheck(true, actual, expectedErrorType, message, "throws");
	}
	static async doesNotThrowAsync(testFunction, error, message) {
		let actual, threw = false;
		try {
			await Promise.resolve(testFunction());
		} catch(e) {
			threw = true;
			actual = e;
			this.rethrowIfSpecialError(actual, error);
		}
		if (threw) {
			this.fail_(actual, null, message, "does not throw");
		}
	}
	static waitForCondition(resultFn, message, timeoutMillisecs, intervalMillisecs) {
		timeoutMillisecs = timeoutMillisecs || DEFAULT_TIMEOUT;
		intervalMillisecs = intervalMillisecs || DEFAULT_POLLING_INTERVAL;
		return new Promise(function(resolveFn, rejectFn) {
			timeoutMillisecs += Date.now();
			let handle = setInterval(function() {
				try {
					let res = resultFn();
					if (res) {
						clearInterval(handle);
						resolveFn(res);
					} else {
						let now = Date.now();
						if (now >= timeoutMillisecs) {
							throw new Error(message ? message + ": condition timeout" : "condition timeout");
						}
					}
				} catch(exc) {
					clearInterval(handle);
					rejectFn(exc);
				}
			}, intervalMillisecs);
		});
	}
	static thrownCheck(shouldThrow, actual, expected, message, operator) {
		this.rethrowIfSpecialError(actual, expected);
		let msg = ".";
		if (expected) {
			let ctorFn = ((expected));
			if (ctorFn.name) {
				msg = ` (${ctorFn.name}).`;
			}
		}
		if (message) {
			msg += ` ${message}`;
		} else {
			msg += ".";
		}
		if (!shouldThrow && expectedException(actual, expected)) {
			this.fail_(actual, expected, 'Got unwanted exception' + message, operator);
		}
		if ((shouldThrow && expected != null && !expectedException(actual, expected)) || (!shouldThrow && actual != null)) {
			this.fail_("" + actual, expected, "thrown error of wrong type " + message, operator);
		}
		return actual;
	}
	static get n4type() {
		return $getReflectionForClass(this, '["Assert","org/eclipse/n4js/mangelhaft/assert/Assert","org.eclipse.n4js.mangelhaft.assert"]');
	}
}
Assert.RETHROWN_SPECIAL_ERROR_TYPES = [
	N4ApiNotImplementedError,
	PreconditionNotMet
];
//# sourceMappingURL=Assert.map