litejs/lib/testman.js

// https://github.com/visionmedia/supertest
// http://sinonjs.org/

!function(exports) {

	var testPoint
	, empty = {}
	, toStr = empty.toString
	, hasOwn = empty.hasOwnProperty
	, proc = typeof process == "undefined" ? { argv: [] } : process
	, color = (proc.stdout || empty).isTTY && proc.argv.indexOf("--no-color") == -1
	, v8 = assert.v8 = {
		statusTexts: [
			"Unknown",
			"Function is optimized",
			"Function is not optimized",
			"Function is always optimized",
			"Function is never optimized",
			"Function is maybe deoptimized",
			"Function is optimized by TurboFan"
		]
	}

	try {
		// chrome --js-flags="--allow-natives-syntax" test.html
		// node --allow-natives-syntax test.js
		["GetOptimizationStatus", "HasFastProperties", "OptimizeFunctionOnNextCall"].map(function(name) {
			v8[name] = Function("fn", "return %" + name+ "(fn)")
		})
		v8.isNative = Function("%GetV8Version()")()
	} catch(e) {}

	function a() {}
	a.x1 = 1
	console.log("fast", assert.v8.HasFastProperties(a))
	a.x2=2
	delete a.x1
	console.log("fast", assert.v8.HasFastProperties(a))

	assert.isOptimized = function isOptimized(fn, args, scope) {
		if (!v8.isNative) {
			this.options.skip = "No access to v8 natives"
			return this
		}
		fn.apply(scope, args)
		fn.apply(scope, args)
		v8.OptimizeFunctionOnNextCall(fn)
		fn.apply(scope, args)
		var status = v8.GetOptimizationStatus(fn)
		/*
		0 0 0 0 0 1 0 0 0 0 0 1
		┬ ┬ ┬ ┬ ┬ ┬ ┬ ┬ ┬ ┬ ┬ ┬
		│ │ │ │ │ │ │ │ │ │ │ └─╸ is function
		│ │ │ │ │ │ │ │ │ │ └───╸ is never optimized
		│ │ │ │ │ │ │ │ │ └─────╸ is always optimized
		│ │ │ │ │ │ │ │ └───────╸ is maybe deoptimized
		│ │ │ │ │ │ │ └─────────╸ is optimized
		│ │ │ │ │ │ └───────────╸ is optimized by TurboFan
		│ │ │ │ │ └─────────────╸ is interpreted
		│ │ │ │ └───────────────╸ is marked for optimization
		│ │ │ └─────────────────╸ is marked for concurrent optimization
		│ │ └───────────────────╸ is optimizing concurrently
		│ └─────────────────────╸ is executing
		└───────────────────────╸ topmost frame is turbo fanned */

		return this.ok(
			status == 1 || (status & 16 || status & 32),
			v8.statusTexts[status],
			isOptimized
		)
	}

	exports.assert = assert
	exports.describe = describe.describe = describe
	exports.test = function(name, next) {
		return testPoint = (testPoint || describe()).test(name, next)
	}



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

	assert.notOk = function notOk(value, message) {
		return this.ok(
			!value,
			message || [actual, "==", expected],
			assertEqual
		)
	}

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


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

	assert.strictEqual = function strictEqual(actual, expected, message) {
		return this.ok(
			actual === expected,
			message || [actual, "===", expected],
			strictEqual
		)
	}

	assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
		return this.ok(
			actual !== expected,
			message || [actual, "!==", expected],
			notStrictEqual
		)
	}

	assert["throws"] = function assertThrows(fn, message) {
		var actual = false
		, expected = true
		try {
			fn()
		} catch(e) {
			actual = true
		}
		return this.ok(actual, message || "throws", assertThrows)
	}

	assert.type = function assertType(thing, expected) {
		var actual = type(thing)
		return this.ok(
			actual === expected,
			"type should be " + expected + ", got " + actual,
			assertType
		)
	}

	assert.anyOf = function anyOf(a, b) {
		return this.ok(
			Array.isArray(b) && b.indexOf(a) != -1,
			"should be one from " + stringify(b) + ", got " + a,
			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) {
		return _deepEqual(actual, expected, [])
	}

	function _deepEqual(actual, expected, circ) {
		// null == undefined
		if (actual === expected || actual == null && actual == expected) return true

		var key, aKeys, eKeys, len
		, aType = type(actual)

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

		key = circ.indexOf(actual)
		if (key > -1) return circ[key + 1] === expected
		circ.push(actual, expected)

		aKeys = Object.keys(actual)
		len = aKeys.length
		if (aType == "array" || aType == "arguments") {
			if (actual.length !== expected.length) return false
		} else {
			eKeys = Object.keys(expected)
			if (len != eKeys.length || !_deepEqual(aKeys.sort(), eKeys.sort(), circ)) return false
		}
		for (; len--; ) {
			key = aKeys[len]
			if (!_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
	}







	var doneTick, started
	, totalCases = 0
	, failedCases = 0
	, totalAsserts = 0
	, passedAsserts = 0
	, bold      = "\x1b[1m"
	, italic    = "\x1b[3m"
	, strike    = "\x1b[9m"
	, underline = "\x1b[4m"
	, red       = "\x1b[31m"
	, green     = "\x1b[32m"
	, reset     = "\x1b[0m"

	if (!color) {
		bold = italic = strike = underline = red = green = reset = ""
	}

	describe.result = ""

	describe.type = type
	describe.diff = diff
	describe.colorDiff = colorDiff
	describe.deepEqual = deepEqual
	describe.stringify = stringify

	function colorDiff(a, b) {
		var res = diff(a, b)
		console.log(
			a.slice(0, res[0]) +
			bold + red + strike + a.slice(res[0], res[0] + res[1]) +
			green + b.slice(res[0], res[0]+res[2]) +
			reset + a.slice(res[0] + res[1])
		)
	}


	function diff(a, b, re) {
		var c = 0, d = a.length, e = b.length
		for (; a.charAt(c) && a.charAt(c) == b.charAt(c); c++);
		for (; d > c && e > c && a.charAt(d - 1) == b.charAt(e - 1); d--) e--;
		return [c, d - c, e - c]
	}

	function describe(name) {
		return new TestSuite(name)
	}




	function TestSuite(name) {
		this.cases = []

		if (!started) {
			started = +new Date()
			print("TAP version 13")
		}

		print("# " + (name || "{unnamed test suite}"))
	}

	TestSuite.prototype = {
		_test: This,
		describe: describe,
		it: function(name, options) {
			return this.test("it " + name, null, options)
		},
		test: function(name, next, options) {
			var testSuite = this
			, testCase = new TestCase(name, options, testSuite)

			if (next) next(testCase)

			return testCase
		},
	}

	function TestCase(name, options, testSuite) {
		var testCase = this
		, opts = testCase.options = options || {}
		testCase.name = (++totalCases) + " - " + (name || "{unnamed test case}")
		testCase.suite = testSuite
		testCase.planned = 0
		testCase.failed = []
		testCase.passedAsserts = 0
		testCase.totalAsserts = 0

		testCase.plan = plan
		testCase.ok = ok
		testCase.end = end

		testSuite.cases.push( testCase )

		if (
			opts.skip ||
			(opts.skip = opts.v8Native && !v8.isNative && "No access to v8 natives") ) {
			testCase.ok = testCase.equal = testCase.type = testCase.run = This
		}

		;["describe", "it", "test"].forEach(function(name) {
			testCase[name] = function() {
				testCase.end()
				return testSuite[name].apply(testSuite, arguments)
			}
		})

		clearTimeout(doneTick)
		doneTick = setTimeout(done, 50)

		function done() {
			if (testCase.ok == describe.it.ok) testSuite.done()
			//else testCase.run(done)
		}

		return testCase
	}

	TestCase.prototype = describe.it = describe.assert = assert

	function plan(num) {
		this.planned = num
		return this
	}

	function ok(value, message, _stackStart) {
		var testCase = this
		totalAsserts++
		testCase.totalAsserts++
		try {
			assert(value, message, _stackStart)
			passedAsserts++
			testCase.passedAsserts++
		} catch(e) {
			testCase.failed.push(testCase.options.noStack ? e.message : e.stack)
		}
		return testCase
	}

	function end() {
		var testCase = this
		, name = testCase.name

		if (testCase.ended) return

		testCase.ended = new Date()

		if (testCase.options.skip) {
			return print("ok " + name + " # skip - " + testCase.options.skip)
		}

		if (testCase.planned != void 0) {
			testCase.equal(testCase.planned, testCase.totalAsserts, null, "planned")
		}

		name += " [" + testCase.passedAsserts + "/" + testCase.totalAsserts + "]"

		if (testCase.failed.length) {
			failedCases++
			print("not ok " + name + "\n---\n" + testCase.failed.join("\n") + "\n---")
		} else {
			print("ok " + name)
		}
	}

		function done(next) {
			if (this.done_) return
			this.done_ = +new Date()

			print("1.." + totalCases)
			print("#" + (failedCases ? "" : green + bold) + " pass  " + (totalCases - failedCases)
				+ "/" + totalCases
				+ " [" + passedAsserts + "/" + totalAsserts + "]"
				+ " in " + (this.done_ - started) + " ms"
				+ reset)

			failedCases && print("#" + red + bold + " fail  " + failedCases
				+ " [" + (totalAsserts - passedAsserts) + "]"
				+ reset)

			if (typeof next == "function") next()
			/*
			* FAILED tests 1, 3, 6
			* Failed 3/6 tests, 50.00% okay
			* PASS 1 test executed in 0.023s, 1 passed, 0 failed, 0 dubious, 0 skipped.
			*/
		}

	function print(str) {
		describe.result += str + "\n"
		console.log(str)
	}

	function This() {
		return this
	}


}(this)


/*
* http://sourceforge.net/projects/portableapps/files/
*/