|
@@ -0,0 +1,712 @@
|
|
|
+/* appjet:version 0.1 */
|
|
|
+
|
|
|
+/* appjet:library */
|
|
|
+
|
|
|
+function assert() {
|
|
|
+ var booleanValue = _validateArguments(1, arguments)[0];
|
|
|
+
|
|
|
+ if (typeof(booleanValue) != 'boolean')
|
|
|
+ error('Bad argument to assert(boolean)');
|
|
|
+
|
|
|
+ _assert(commentArg(1, arguments), booleanValue === true, 'Call to assert(boolean) with false');
|
|
|
+}
|
|
|
+
|
|
|
+function assertTrue() {
|
|
|
+ var booleanValue = _validateArguments(1, arguments)[0];
|
|
|
+
|
|
|
+ if (typeof(booleanValue) != 'boolean')
|
|
|
+ error('Bad argument to assertTrue(boolean)');
|
|
|
+
|
|
|
+ _assert(commentArg(1, arguments), booleanValue === true, 'Call to assertTrue(boolean) with false');
|
|
|
+}
|
|
|
+
|
|
|
+function assertFalse() {
|
|
|
+ var booleanValue = _validateArguments(1, arguments)[0];
|
|
|
+
|
|
|
+ if (typeof(booleanValue) != 'boolean')
|
|
|
+ error('Bad argument to assertFalse(boolean)');
|
|
|
+
|
|
|
+ _assert(commentArg(1, arguments), booleanValue === false, 'Call to assertFalse(boolean) with true');
|
|
|
+}
|
|
|
+
|
|
|
+function assertEquals() {
|
|
|
+ var args = _validateArguments(2, arguments),
|
|
|
+ exp = args[0], act = args[1];
|
|
|
+ _assert(commentArg(2, arguments), exp === act, 'Expected ' + _displayStringForValue(exp) + ' but was ' + _displayStringForValue(act));
|
|
|
+}
|
|
|
+
|
|
|
+function assertNotEquals() {
|
|
|
+ var args = _validateArguments(2, arguments),
|
|
|
+ exp = args[0], act = args[1];
|
|
|
+ _assert(commentArg(2, arguments), exp !== act, 'Expected not to be ' + _displayStringForValue(act));
|
|
|
+}
|
|
|
+
|
|
|
+function assertNull() {
|
|
|
+ var aVar = _validateArguments(1, arguments)[0];
|
|
|
+ _assert(commentArg(1, arguments), aVar === null, 'Expected ' + _displayStringForValue(null) + ' but was ' + _displayStringForValue(aVar));
|
|
|
+}
|
|
|
+
|
|
|
+function assertNotNull() {
|
|
|
+ var aVar = _validateArguments(1, arguments)[0];
|
|
|
+ _assert(commentArg(1, arguments), aVar !== null, 'Expected not to be ' + _displayStringForValue(null));
|
|
|
+}
|
|
|
+
|
|
|
+function assertUndefined() {
|
|
|
+ var aVar = _validateArguments(1, arguments)[0];
|
|
|
+ _assert(commentArg(1, arguments), aVar === undefined, 'Expected ' + _displayStringForValue(undefined) + ' but was ' + _displayStringForValue(aVar));
|
|
|
+}
|
|
|
+
|
|
|
+function assertNotUndefined() {
|
|
|
+ var aVar = _validateArguments(1, arguments)[0];
|
|
|
+ _assert(commentArg(1, arguments), aVar !== undefined, 'Expected not to be ' + _displayStringForValue(undefined));
|
|
|
+}
|
|
|
+
|
|
|
+function assertNaN() {
|
|
|
+ var aVar = _validateArguments(1, arguments)[0];
|
|
|
+ _assert(commentArg(1, arguments), isNaN(aVar), 'Expected NaN');
|
|
|
+}
|
|
|
+
|
|
|
+function assertNotNaN() {
|
|
|
+ var aVar = _validateArguments(1, arguments)[0];
|
|
|
+ _assert(commentArg(1, arguments), !isNaN(aVar), 'Expected not NaN');
|
|
|
+}
|
|
|
+
|
|
|
+function assertHTMLEquals() {
|
|
|
+ var args = _validateArguments(2, arguments),
|
|
|
+ exp = args[0], act = args[1];
|
|
|
+ expStd = _standardizeHTML(exp),
|
|
|
+ actStd = _standardizeHTML(act);
|
|
|
+
|
|
|
+ assertEquals(commentArg(2, arguments)||"", expStd, actStd);
|
|
|
+}
|
|
|
+
|
|
|
+var _helper = null;//import({}, "lib-simple-htmlparser", "lib-xmldom");
|
|
|
+
|
|
|
+function _standardizeHTML(html) {
|
|
|
+ result = _helper.HTMLtoXML("<scrap>"+html+"</scrap>");
|
|
|
+ xmldoc = new _helper.XMLDoc(result);
|
|
|
+ result = xmldoc. getUnderlyingXMLText();
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+function assertObjectEquals() {
|
|
|
+ var args = _validateArguments(2, arguments),
|
|
|
+ exp = args[0], act = args[1];
|
|
|
+ if (exp === act) return;
|
|
|
+ var comment = commentArg(2,arguments);
|
|
|
+ var msg = comment ? comment : '';
|
|
|
+ var type = jsuTrueTypeOf(exp);
|
|
|
+ var isEqual = type == jsuTrueTypeOf(act);
|
|
|
+ if (isEqual) {
|
|
|
+ switch (type) {
|
|
|
+ case 'String':
|
|
|
+ case 'Number':
|
|
|
+ isEqual = exp == act;
|
|
|
+ break;
|
|
|
+ case 'Boolean':
|
|
|
+ case 'Date':
|
|
|
+ isEqual = exp === act;
|
|
|
+ break;
|
|
|
+ case 'RegExp':
|
|
|
+ case 'Function':
|
|
|
+ isEqual = exp.toString() === act.toString();
|
|
|
+ break;
|
|
|
+ default: //Object | Array
|
|
|
+ isEqual = exp.length === act.length;
|
|
|
+ if (isEqual)
|
|
|
+ if (comment == null)
|
|
|
+ _assertRecursiveEquals(exp, act, assertObjectEquals);
|
|
|
+ else
|
|
|
+ _assertRecursiveEquals("Nested: "+comment, exp, act, assertObjectEquals);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ _assert(msg, isEqual, 'Expected ' + _displayStringForValue(exp) + ' but was ' + _displayStringForValue(act));
|
|
|
+}
|
|
|
+
|
|
|
+assertArrayEquals = assertObjectEquals;
|
|
|
+
|
|
|
+function assertHashEquals() {
|
|
|
+ var args = _validateArguments(2, arguments),
|
|
|
+ exp = args[0], act = args[1];
|
|
|
+ var comment = commentArg(2, arguments);
|
|
|
+ if (comment == null)
|
|
|
+ _assertRecursiveEquals(exp, act, assertEquals);
|
|
|
+ else
|
|
|
+ _assertRecursiveEquals(comment, exp, act, assertEquals);
|
|
|
+}
|
|
|
+
|
|
|
+function _assertRecursiveEquals() {
|
|
|
+ var args = _validateArguments(3, arguments),
|
|
|
+ exp = args[0], act = args[1], compare = args[2];
|
|
|
+ var comment = commentArg(3, arguments);
|
|
|
+ var comment = comment ? comment + "\n" : "";
|
|
|
+ for (var key in exp) {
|
|
|
+ assertTrue(comment + "Expected had key " + key + " that was not found", key in act);
|
|
|
+ compare(
|
|
|
+ comment + "Value for key " + key + " mismatch - expected = " + exp[key] + ", actual = " + act[key],
|
|
|
+ exp[key], act[key]
|
|
|
+ );
|
|
|
+ }
|
|
|
+ for (var key in act) {
|
|
|
+ assertTrue(comment + "Actual had key " + key + " that was not expected", key in exp);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+function assertRoughlyEquals() {
|
|
|
+ var args = _validateArguments(3, arguments),
|
|
|
+ exp = args[0], act = args[1], tolerance = args[2];
|
|
|
+ assertTrue(
|
|
|
+ "Expected " + exp + ", but got " + act + " which was more than " + tolerance + " away",
|
|
|
+ Math.abs(exp - act) < tolerance
|
|
|
+ );
|
|
|
+}
|
|
|
+
|
|
|
+function assertContains() {
|
|
|
+ var args = _validateArguments(2, arguments),
|
|
|
+ contained = args[0], container = args[1];
|
|
|
+ assertTrue(
|
|
|
+ "Expected '" + container + "' to contain '" + contained + "'",
|
|
|
+ container.indexOf(contained) != -1
|
|
|
+ );
|
|
|
+}
|
|
|
+
|
|
|
+function assertEvaluatesToTrue() {
|
|
|
+ var value = _validateArguments(1, arguments)[0];
|
|
|
+ if (!value)
|
|
|
+ fail(commentArg(1, arguments));
|
|
|
+}
|
|
|
+
|
|
|
+function assertEvaluatesToFalse() {
|
|
|
+ var value = _validateArguments(1, arguments)[0];
|
|
|
+ if (value)
|
|
|
+ fail(commentArg(1, arguments));
|
|
|
+}
|
|
|
+
|
|
|
+function _assert(comment, booleanValue, failureMessage) {
|
|
|
+ if (!booleanValue)
|
|
|
+ throw new JsUnitException(comment, failureMessage);
|
|
|
+}
|
|
|
+
|
|
|
+/**@ignore*/
|
|
|
+function argumentsIncludeComments(expectedNumberOfNonCommentArgs, args) {
|
|
|
+ return args.length == expectedNumberOfNonCommentArgs + 1;
|
|
|
+}
|
|
|
+
|
|
|
+/**@ignore*/
|
|
|
+function commentArg(expectedNumberOfNonCommentArgs, args) {
|
|
|
+ if (argumentsIncludeComments(expectedNumberOfNonCommentArgs, args))
|
|
|
+ return args[0];
|
|
|
+
|
|
|
+ return null;
|
|
|
+}
|
|
|
+
|
|
|
+/**@ignore*/
|
|
|
+/*function nonCommentArg(desiredNonCommentArgIndex, expectedNumberOfNonCommentArgs, args) {
|
|
|
+ return argumentsIncludeComments(expectedNumberOfNonCommentArgs, args) ?
|
|
|
+ args[desiredNonCommentArgIndex] :
|
|
|
+ args[desiredNonCommentArgIndex - 1];
|
|
|
+}*/
|
|
|
+
|
|
|
+function _validateArguments(expectedNumberOfNonCommentArgs, args) {
|
|
|
+ if (!( args.length == expectedNumberOfNonCommentArgs ||
|
|
|
+ (args.length == expectedNumberOfNonCommentArgs + 1 && typeof(args[0]) == 'string') ))
|
|
|
+ error('Incorrect arguments passed to assert function');
|
|
|
+ return Array.prototype.slice.call(args, -expectedNumberOfNonCommentArgs);
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * A more functional typeof
|
|
|
+ * @param Object o
|
|
|
+ * @return String
|
|
|
+ */
|
|
|
+function jsuTrueTypeOf(something) {
|
|
|
+ var result = typeof something;
|
|
|
+ try {
|
|
|
+ switch (result) {
|
|
|
+ case 'string':
|
|
|
+ case 'boolean':
|
|
|
+ case 'number':
|
|
|
+ break;
|
|
|
+ case 'object':
|
|
|
+ case 'function':
|
|
|
+ switch (something.constructor)
|
|
|
+ {
|
|
|
+ case String:
|
|
|
+ result = 'String';
|
|
|
+ break;
|
|
|
+ case Boolean:
|
|
|
+ result = 'Boolean';
|
|
|
+ break;
|
|
|
+ case Number:
|
|
|
+ result = 'Number';
|
|
|
+ break;
|
|
|
+ case Array:
|
|
|
+ result = 'Array';
|
|
|
+ break;
|
|
|
+ case RegExp:
|
|
|
+ result = 'RegExp';
|
|
|
+ break;
|
|
|
+ case Function:
|
|
|
+ result = 'Function';
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ var m = something.constructor.toString().match(/function\s*([^( ]+)\(/);
|
|
|
+ if (m)
|
|
|
+ result = m[1];
|
|
|
+ else
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ finally {
|
|
|
+ result = result.substr(0, 1).toUpperCase() + result.substr(1);
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+function _displayStringForValue(aVar) {
|
|
|
+ var result = '<' + aVar + '>';
|
|
|
+ if (aVar != null) {
|
|
|
+ result += ' (' + jsuTrueTypeOf(aVar) + ')';
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/**Call from within test to end it with failure*/
|
|
|
+function fail(failureMessage) {
|
|
|
+ throw new JsUnitException("Call to fail()", failureMessage);
|
|
|
+}
|
|
|
+
|
|
|
+/**Call from within test to end it with error*/
|
|
|
+function error(errorMessage) {
|
|
|
+ var errorObject = new Object();
|
|
|
+ errorObject.description = errorMessage;
|
|
|
+ throw errorObject;
|
|
|
+}
|
|
|
+
|
|
|
+/**This exception is used by jsunit for failures.*/
|
|
|
+function JsUnitException(comment, message) {
|
|
|
+ this.isTestException = true;
|
|
|
+ this.comment = comment;
|
|
|
+ this.testMessage = message;
|
|
|
+}
|
|
|
+
|
|
|
+var counter = 0;
|
|
|
+
|
|
|
+/* appjet:server */
|
|
|
+
|
|
|
+import("lib-utils/jsunit");
|
|
|
+
|
|
|
+function assertJsUnitException(comment, allegedJsUnitException) {
|
|
|
+ assertNotNull(comment, allegedJsUnitException);
|
|
|
+ assert(comment, allegedJsUnitException.isTestException);
|
|
|
+ assertNotUndefined(comment, allegedJsUnitException.comment);
|
|
|
+}
|
|
|
+
|
|
|
+function assertNonJsUnitException(comment, allegedNonJsUnitException) {
|
|
|
+ assertNotNull(comment, allegedNonJsUnitException);
|
|
|
+ assertUndefined(comment, allegedNonJsUnitException.isTestUnitException);
|
|
|
+ assertNotUndefined(comment, allegedNonJsUnitException.description);
|
|
|
+}
|
|
|
+
|
|
|
+page.testSuite = [
|
|
|
+ function assertWorks() {
|
|
|
+ assert("true should be true", true);
|
|
|
+ assert(true);
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertTrueWorks() {
|
|
|
+ assertTrue("true should be true", true);
|
|
|
+ assertTrue(true);
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertFalseWorks() {
|
|
|
+ assertFalse("false should be false", false);
|
|
|
+ assertFalse(false);
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertEqualsWorks() {
|
|
|
+ assertEquals("1 should equal 1", 1, 1);
|
|
|
+ assertEquals(1, 1);
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertNotEqualsWorks() {
|
|
|
+ assertNotEquals("1 should not equal 2", 1, 2);
|
|
|
+ assertNotEquals(1, 2);
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertNullWorks() {
|
|
|
+ assertNull("null should be null", null);
|
|
|
+ assertNull(null);
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertNotNullWorks() {
|
|
|
+ assertNotNull("1 should not be null", 1);
|
|
|
+ assertNotNull(1);
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertUndefinedWorks() {
|
|
|
+ var myVar;
|
|
|
+ assertUndefined("A declared but unassigned variable should have the undefined value", myVar);
|
|
|
+ assertUndefined(myVar);
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertNotUndefinedWorks() {
|
|
|
+ assertNotUndefined("1 should not be undefined", 1);
|
|
|
+ assertNotUndefined(1);
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertNaNWorks() {
|
|
|
+ assertNaN("a string should not be a number", "string");
|
|
|
+ assertNaN("string");
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertNotNaNWorks() {
|
|
|
+ assertNotNaN("1 should not be not a number", 1);
|
|
|
+ assertNotNaN(1);
|
|
|
+ },
|
|
|
+
|
|
|
+ function failWorks() {
|
|
|
+ var excep = null;
|
|
|
+ try {
|
|
|
+ fail("Failure message");
|
|
|
+ } catch (e) {
|
|
|
+ excep = e;
|
|
|
+ }
|
|
|
+ assertJsUnitException("fail(string) should throw a JsUnitException", excep);
|
|
|
+ },
|
|
|
+
|
|
|
+ function tooFewArguments() {
|
|
|
+ var excep = null;
|
|
|
+ try {
|
|
|
+ assert();
|
|
|
+ } catch (e1) {
|
|
|
+ excep = e1;
|
|
|
+ }
|
|
|
+ assertNonJsUnitException("Calling an assertion function with too few arguments should throw an exception", excep);
|
|
|
+ },
|
|
|
+
|
|
|
+ function tooManyArguments() {
|
|
|
+ var excep = null;
|
|
|
+ try {
|
|
|
+ assertEquals("A comment", true, true, true);
|
|
|
+ } catch (e2) {
|
|
|
+ excep = e2;
|
|
|
+ }
|
|
|
+ assertNonJsUnitException("Calling an assertion function with too many arguments should throw an exception", excep);
|
|
|
+ },
|
|
|
+
|
|
|
+ function invalidCommentArgumentType() {
|
|
|
+ var excep = null;
|
|
|
+ try {
|
|
|
+ assertNull(1, true);
|
|
|
+ } catch (e3) {
|
|
|
+ excep = e3;
|
|
|
+ }
|
|
|
+ assertNonJsUnitException("Calling an assertion function with a non-string comment should throw an exception", excep);
|
|
|
+ },
|
|
|
+
|
|
|
+ function invalidArgumentType() {
|
|
|
+ var excep = null;
|
|
|
+ try {
|
|
|
+ assert("string");
|
|
|
+ } catch (e) {
|
|
|
+ excep = e;
|
|
|
+ }
|
|
|
+ assertNonJsUnitException("Calling an assertion function with an invalid argument should throw an exception", excep);
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertArrayEqualsWorks() {
|
|
|
+ var array1 = ["foo", "bar", "foobar"];
|
|
|
+ var array2 = ["foo", "bar", "foobar"];
|
|
|
+ var array3 = ["foo", "bar"];
|
|
|
+ var array4 = ["bar", "foo", "foobar"];
|
|
|
+
|
|
|
+ assertArrayEquals([undefined],[undefined]);
|
|
|
+ assertArrayEquals(array1, array1);
|
|
|
+ assertArrayEquals(array1, array2);
|
|
|
+ try {
|
|
|
+ assertArrayEquals(array1, undefined);
|
|
|
+ fail("Should not be equal to undefined");
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("Should be a JsUnitException", e);
|
|
|
+ if (e.comment == "Call to fail()")
|
|
|
+ fail(e.comment + e.testMessage); //tried fail is also caught
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ assertArrayEquals(array1, array3);
|
|
|
+ fail("Should not be equal");
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("Should be a JsUnitException", e);
|
|
|
+ if (e.comment == "Call to fail()")
|
|
|
+ fail(e.comment + e.testMessage); //tried fail is also caught
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ assertArrayEquals(array1, array4);
|
|
|
+ fail("Should not be equal");
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("Should be a JsUnitException", e);
|
|
|
+ if (e.comment == "Call to fail()")
|
|
|
+ fail(e.comment + e.testMessage); //tried fail is also caught
|
|
|
+ }
|
|
|
+ var array5 = ['foo', 'bar', ['nested', 'bar'], 'foobar'];
|
|
|
+ var array6 = ['foo', 'bar', ['nested', 'bar'], 'foobar'];
|
|
|
+ var array7 = ['foo', 'bar', ['nested', 'foo'], 'foobar'];
|
|
|
+ assertArrayEquals('Equal nested arrays', array5, array6);
|
|
|
+ try {
|
|
|
+ assertArrayEquals(array5, array7);
|
|
|
+ var failure = 'Differing nested arrays found to be equal';
|
|
|
+ fail(failure);
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("Should be a JsUnitException", e);
|
|
|
+ if (e.testMessage == failure)
|
|
|
+ fail(e.testMessage);
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertObjectEqualsWorksOnObjects() {
|
|
|
+ var failure;
|
|
|
+ assertObjectEquals(undefined, undefined);
|
|
|
+ var o1 = {foo:'bar'};
|
|
|
+ var o2 = {foo:'bar'};
|
|
|
+ assertObjectEquals('Single object', o1, o1);
|
|
|
+ assertObjectEquals('Same objects', o1, o2);
|
|
|
+ var o3 = {foo:'foo'};
|
|
|
+ var o4 = {foo:'foo',
|
|
|
+ bar: function () {
|
|
|
+ this.foo = 'bar';
|
|
|
+ delete this.bar;
|
|
|
+ }};
|
|
|
+ var o5 = {foo:'foo',
|
|
|
+ bar: function () {
|
|
|
+ this.foo = 'foo';
|
|
|
+ delete this.bar;
|
|
|
+ }};
|
|
|
+ try {
|
|
|
+ assertObjectEquals(o1, o3);
|
|
|
+ fail(failure = 'Simple differing objects found to be the same');
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("Should be a JsUnitException", e);
|
|
|
+ if (e.testMessage == failure)
|
|
|
+ fail(e.testtMessage);
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ assertObjectEquals(o3, o4);
|
|
|
+ fail(failure = 'Object with additional fields found to be the same with non-grown one.');
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("Should be a JsUnitException", e);
|
|
|
+ if (e.testMessage == failure)
|
|
|
+ fail(e.testMessage);
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ assertObjectEquals(o4, o5);
|
|
|
+ fail(failure = 'Objects with different methods found to be the same');
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("Should be a JsUnitException", e);
|
|
|
+ if (e.testMessage == failure)
|
|
|
+ fail(e.testMessage);
|
|
|
+ }
|
|
|
+
|
|
|
+ o4.bar();
|
|
|
+ assertObjectEquals('Different objects, made to be the same', o1, o4);
|
|
|
+ try {
|
|
|
+ assertObjectEquals({ts:new Date()}, {ts:new Date()});
|
|
|
+ fail(failure = 'Objects with different Date attributes found to be the same');
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("Should be a JsUnitException", e);
|
|
|
+ if (e.testMessage == failure)
|
|
|
+ fail(e.testMessage);
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ assertObjectEquals(new Date(), new Date());
|
|
|
+ fail(failure = 'Different Date objects found to be the same');
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("Should be a JsUnitException", e);
|
|
|
+ if (e.testMessage == failure)
|
|
|
+ fail(e.testMessage);
|
|
|
+ }
|
|
|
+ assertObjectEquals(/a/, new RegExp('a'));
|
|
|
+ assertObjectEquals(/a/i, new RegExp('a', 'i'));
|
|
|
+ assertObjectEquals(function(a,b){return a+b;}, function(a,b){return a+b;});
|
|
|
+ //XXX challenge for the future
|
|
|
+ //assertObjectEquals(function(a,b){return a+b}, new Function("a","b","return a+b"));
|
|
|
+
|
|
|
+ try {
|
|
|
+ assertObjectEquals(/a/i, new RegExp('a', 'g'));
|
|
|
+ fail(failure = 'RegExp with different flags found to be the same');
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("Should be a JsUnitException", e);
|
|
|
+ if (e.testMessage == failure)
|
|
|
+ fail(e.testMessage);
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ assertObjectEquals(/a/, new RegExp('b'));
|
|
|
+ fail(failure = 'RegExp with different patterns found to be the same');
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("Should be a JsUnitException", e);
|
|
|
+ if (e.testMessage == failure)
|
|
|
+ fail(e.testMessage);
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertObjectEqualsWorksOnStrings() {
|
|
|
+ var s1 = 'string1';
|
|
|
+ var s2 = 'string1';
|
|
|
+ var newS1 = new String('string1');
|
|
|
+ assertObjectEquals('Same Strings', s1, s2);
|
|
|
+ assertObjectEquals('Same Strings 1 with new', s1, newS1);
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertObjectEqualsWorksOnNumbers() {
|
|
|
+ var failure;
|
|
|
+ var n1 = 1;
|
|
|
+ var n2 = 1;
|
|
|
+ var newN1 = new Number(1);
|
|
|
+ assertObjectEquals('Same Numbers', n1, n2);
|
|
|
+ assertObjectEquals('Same Numbers 1 with new', n1, newN1);
|
|
|
+ var n3 = 2;
|
|
|
+ var newN3 = new Number(2);
|
|
|
+ try {
|
|
|
+ assertObjectEquals(n1, n3);
|
|
|
+ fail(failure = 'Different Numbers');
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("Should be a JsUnitException", e);
|
|
|
+ if (e.testMessage == failure)
|
|
|
+ fail(e.testMessage);
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ assertObjectEquals(newN1, newN3);
|
|
|
+ fail(failure = 'Different New Numbers');
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("Should be a JsUnitException", e);
|
|
|
+ if (e.testMessage == failure)
|
|
|
+ fail(e.testMessage);
|
|
|
+ }
|
|
|
+
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertEvaluatesToTrueWorks() {
|
|
|
+ assertEvaluatesToTrue("foo");
|
|
|
+ assertEvaluatesToTrue(true);
|
|
|
+ assertEvaluatesToTrue(1);
|
|
|
+ try {
|
|
|
+ assertEvaluatesToTrue(null);
|
|
|
+ fail("Should have thrown a JsUnitException");
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("Should be a JsUnitException", e);
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertEvaluatesToFalseWorks() {
|
|
|
+ assertEvaluatesToFalse("");
|
|
|
+ assertEvaluatesToFalse(null);
|
|
|
+ assertEvaluatesToFalse(false);
|
|
|
+ assertEvaluatesToFalse(0);
|
|
|
+ try {
|
|
|
+ assertEvaluatesToFalse("foo");
|
|
|
+ fail("Should have thrown a JsUnitException");
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("Should be a JsUnitException", e);
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertHtmlEqualsWorks() {
|
|
|
+ assertHTMLEquals("<div id=mydiv>foobar</div>", "<div id='mydiv'>foobar</div>");
|
|
|
+ assertHTMLEquals("<p/>", "<p></p>");
|
|
|
+ assertHTMLEquals("foo bar", "foo bar");
|
|
|
+ assertHTMLEquals("a comment", "<p id='foo'>foo bar</p>", "<p id=foo>foo bar</p>");
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertHashEqualsWorks() {
|
|
|
+ var hash1 = new Array();
|
|
|
+ hash1["key1"] = "value1";
|
|
|
+ hash1["key2"] = "value2";
|
|
|
+
|
|
|
+ var hash2 = new Array();
|
|
|
+ try {
|
|
|
+ assertHashEquals(hash1, hash2);
|
|
|
+ fail();
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("hash2 is empty", e);
|
|
|
+ }
|
|
|
+ hash2["key1"] = "value1";
|
|
|
+ try {
|
|
|
+ assertHashEquals(hash1, hash2);
|
|
|
+ fail();
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("hash2 is a of a different size", e);
|
|
|
+ }
|
|
|
+ hash2["key2"] = "foo";
|
|
|
+ try {
|
|
|
+ assertHashEquals(hash1, hash2);
|
|
|
+ fail();
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("hash2 has different values", e);
|
|
|
+ }
|
|
|
+ hash2["key2"] = "value2";
|
|
|
+ assertHashEquals(hash1, hash2);
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertRoughlyEqualsWorks() {
|
|
|
+ assertRoughlyEquals(1, 1.1, 0.5);
|
|
|
+ assertRoughlyEquals(1, 5, 6);
|
|
|
+ assertRoughlyEquals(-4, -5, 2);
|
|
|
+ assertRoughlyEquals(-0.5, 0.1, 0.7);
|
|
|
+ try {
|
|
|
+ assertRoughlyEquals(1, 2, 0.5);
|
|
|
+ } catch (e) {
|
|
|
+ assertJsUnitException("1 and 2 are more than 0.5 apart", e);
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ function assertContainsWorks() {
|
|
|
+ assertContains("foo", "foobar");
|
|
|
+ assertContains("ooba", "foobar");
|
|
|
+ assertContains("bar", "foobar");
|
|
|
+ },
|
|
|
+];
|
|
|
+
|
|
|
+/**@ignore*/
|
|
|
+function FooBarThingy() {
|
|
|
+ this.foo = 'bar';
|
|
|
+}
|
|
|
+
|
|
|
+/**@ignore*/
|
|
|
+FooBarThingy.prototype.bar = function() {
|
|
|
+ return this.foo;
|
|
|
+};
|
|
|
+
|
|
|
+page.testSuite.push(function testTrueTypeOf() {
|
|
|
+ assertEquals('Boolean', jsuTrueTypeOf(true));
|
|
|
+ assertEquals('Using new', 'Boolean', jsuTrueTypeOf(new Boolean('1')));
|
|
|
+
|
|
|
+ assertEquals('Number', jsuTrueTypeOf(1));
|
|
|
+ var GI = new Number(1);
|
|
|
+ assertEquals('Using new', 'Number', jsuTrueTypeOf(GI));
|
|
|
+ assertEquals('Number', jsuTrueTypeOf(1.5));
|
|
|
+
|
|
|
+ assertEquals('String', jsuTrueTypeOf('foo'));
|
|
|
+ assertEquals('Using new', 'String', jsuTrueTypeOf(new String('foo')));
|
|
|
+
|
|
|
+ assertEquals('Using new', 'Function', jsuTrueTypeOf(new Function()));
|
|
|
+ assertEquals('Function', jsuTrueTypeOf(function foo() {}));
|
|
|
+ assertEquals('Function', jsuTrueTypeOf(testTrueTypeOf));
|
|
|
+
|
|
|
+ assertEquals('RegExp', jsuTrueTypeOf(/foo/));
|
|
|
+ assertEquals('Using new', 'RegExp', jsuTrueTypeOf(new RegExp('foo')));
|
|
|
+
|
|
|
+ var o = {foo: 'bar'};
|
|
|
+ assertEquals('Object', jsuTrueTypeOf(o));
|
|
|
+ var o = new FooBarThingy();
|
|
|
+ assertEquals('FooBarThingy', jsuTrueTypeOf(o));
|
|
|
+ assertEquals('String', jsuTrueTypeOf(o.foo));
|
|
|
+ assertEquals('String', jsuTrueTypeOf(o.bar()));
|
|
|
+ assertEquals('Function', jsuTrueTypeOf(o.bar));
|
|
|
+
|
|
|
+ assertEquals('Object without constructor', 'Object', jsuTrueTypeOf(appjet));
|
|
|
+});
|
|
|
+
|
|
|
+import("lib-utils/runner");
|
|
|
+
|
|
|
+runTestsByDefault();
|