litejs/test/assert.js

Single-page application framework

!function(exports) {
	var empty = {}
	, toStr = empty.toString
	, hasOwn = empty.hasOwnProperty
	, isArray = Array.isArray

	module.exports = assert

	function assert(value, message, x, _stackStart) {
		if (!value) {
			if (!message) {
				message = stringify(value) + " == true"
			} else if (isArray(message)) {
				message = message[1] +
				"\nexpected: " + stringify(message[2], 160) +
				"\nactual:   " + stringify(message[0], 160)
			}
			throw new AssertionError(message, _stackStart || assert)
		}
	}
	assert.ok = assert

	assert.notOk = function notOk(value, message, x, _stackStart) {
		assert(
			!value,
			message || [value, "==", null],
			null,
			_stackStart || notOk
		)
	}

	assert.equal =
	assert.deepEqual = function assertEqual(actual, expected, message, _stackStart) {
		assert(
			_deepEqual(actual, expected, []),
			message || [actual, "==", expected],
			null,
			_stackStart || assertEqual
		)
	}


	assert.notEqual =
	assert.notDeepEqual = function notEqual(actual, expected, message, _stackStart) {
		assert(
			!_deepEqual(actual, expected, []),
			message || [actual, "!=", expected],
			null,
			_stackStart || notEqual
		)
	}

	assert.strictEqual = function strictEqual(actual, expected, message, _stackStart) {
		assert(
			actual === expected,
			message || [actual, "===", expected],
			null,
			_stackStart || strictEqual
		)
	}

	assert.notStrictEqual = function notStrictEqual(actual, expected, message, _stackStart) {
		assert(
			actual !== expected,
			message || [actual, "!==", expected],
			null,
			_stackStart || notStrictEqual
		)
	}

	assert["throws"] = function assertThrows(fn, message, x, _stackStart) {
		var actual = false
		, expected = true
		try {
			fn()
		} catch(e) {
			actual = true
		}
		assert(actual, message || "throws", null, _stackStart || assertThrows)
	}

	assert.type = function assertType(thing, expected, x, _stackStart) {
		var actual = type(thing)
		assert(
			actual === expected,
			"type should be " + expected + ", got " + actual,
			null,
			_stackStart || assertType
		)
	}

	assert.anyOf = function anyOf(a, b, x, _stackStart) {
		assert(
			isArray(b) && b.indexOf(a) != -1,
			"should be one from " + stringify(b) + ", got " + a,
			null,
			_stackStart || anyOf
		)
	}


	function AssertionError(message, _stackStart) {
		this.name = "AssertionError"
		this.message = message
		if (Error.captureStackTrace) {
			Error.captureStackTrace(this, _stackStart || AssertionError)
		} else {
			this.stack = this.toString() + "\n" + (new Error()).stack
		}
	}
	AssertionError.prototype = Object.create(Error.prototype)


	function _deepEqual(actual, expected, circ) {
		if (
			actual === expected ||
			// null == undefined
			expected === null && actual == expected ||
			// make NaN equal to NaN
			actual !== actual && expected !== expected
		) return true

		var key, aKeys, len
		, aType = typeof actual

		if (
			aType !== "object" ||
			actual == null ||
			aType !== typeof expected ||
			(aType = type(actual)) != type(expected) ||
			actual.constructor !== expected.constructor ||
			(aType == "date" && actual.getTime() !== expected.getTime()) ||
			(aType == "regexp" && ""+actual !== ""+expected)
		) {
			return false
		}

		key = circ.indexOf(actual)
		if (key > -1) return true
		circ.push(actual)

		if (aType == "array" || aType == "arguments") {
			len = actual.length
			if (len !== expected.length) return false
			for (; len--; ) {
				if (!_deepEqual(actual[len], expected[len], circ)) return false
			}
		} else {
			aKeys = Object.keys(actual)
			len = aKeys.length
			if (len !== Object.keys(expected).length) return false
			for (; len--; ) {
				key = aKeys[len]
				if (
					!hasOwn.call(expected, key) ||
					!_deepEqual(actual[key], expected[key], circ)
				) return false
			}
		}
		return true
	}

	function type(obj) {
		// Standard clearly states that NaN is a number
		// but this is not useful for testing.
		return obj !== obj ? "nan" : toStr.call(obj).slice(8, -1).toLowerCase()
	}

	function stringify(item, maxLen) {
		var max = maxLen > 9 ? maxLen : 70
		, str = _stringify(item, max, [])
		return str.length > max ? str.slice(0, max - 3) + ".." + str.slice(-1) : str
	}

	function _stringify(item, max, circ) {
		var i, tmp
		, left = max
		, t = type(item)
		, str =
			t === "string" ? JSON.stringify(item) :
			t === "function" ? ("" + item).split(/n | *\{/)[1] :
			(!item || t === "number" || t === "regexp" || item === true) ? "" + item :
			item.toJSON ? item.toJSON() :
			item

		if (typeof str == "object") {
			if (circ.indexOf(str) > -1) return "[Circular]"
			circ.push(str)
			tmp = []
			for (i in str) if (hasOwn.call(str, i)) {
				i = (t === "object" ? i + ":" : "") + _stringify(str[i], left, circ)
				tmp.push(i)
				left -= i.length
				if (left < 0) break
			}
			str =
			t === "array" ? "[" + tmp + "]" :
			t === "arguments" ? t + "[" + tmp + "]" :
			"{" + tmp + "}"

			if (t === "object" && item.constructor !== Object) {
				str = item.constructor.name + str
			}
		}

		return str
	}
}(this)