Set of default assertions

[Ates]

Do you think that the set of default assertions need to be extended?
To recap, here's the current set that's borrowed from jsUnit:

* assertTrue
* assertFalse
* assertEquals
* assertNotEquals
* assertNull
* assertNotNull
* assertUndefined
* assertNotUndefined
* assertNaN
* assertNotNaN
* fail

Do you think it would be necessary to have a wider variety to support
things like deep object comparisons, type checks etc?

[nlloyds]

It might also be helpful to have assert(Not)Identical in addition to
assertEqual. I know in JsUnitTest, one does type coercion and the
other doesn't, like == vs ===.

Other useful ones included in that library (that don't necessarily
need to be in jsUnity, but it's good to know they exist) are:

assert(Not)EnumEqual (for comparing the contents of arrays)
assert(Not)HashEqual (same for objects)
assert(Not)NullOrUndefined
assert(No)Match (for regex matches)
assert(Not)Instanceof
assertRespondsTo
assert(Nothing)Raised(d)

Thanks,

Nathan

[Ates]

Thanks for the input, Nathan. I think assert(Not)Identical would be
very useful (in fact, it could make my life easier with some test
cases that I already have.) I'll try to add these in the upcoming
release.

Ates

[Ates]

On Mar 10, 1:18 pm, Ates <ates.go...@gmail.com> wrote:
> Thanks for the input, Nathan. I think assert(Not)Identical would be
> very useful (in fact, it could make my life easier with some test
> cases that I already have.) I'll try to add these in the upcoming
> release.

I've just committed a change with new/improved assertion functions.
These will be going into v0.6. The full set has now become:

assertEqual: function (expected, actual, message)
assertException: function (fn, message)
assertFalse: function (actual, message)
assertIdentical: function (expected, actual, message)
assertInstanceOf: function (cls, actual, message)
assertMatch: function (re, actual, message)
assertNaN: function (actual, message)
assertNotEqual: function (expected, actual, message)
assertNotIdentical: function (expected, actual, message)
assertNotInstanceOf: function (cls, actual, message)
assertNotMatch: function (re, actual, message)
assertNotNaN: function (actual, message)
assertNotNull: function (actual, message)
assertNotTypeOf: function (typ, actual, message)
assertNotUndefined: function (actual, message)
assertNull: function (actual, message)
assertTrue: function (actual, message)
assertTypeOf: function (typ, actual, message)
assertUndefined: function (actual, message)
fail: function (message)


Ates

[Ates]

On Mar 25, 2:01 am, Ates <ates.go...@gmail.com> wrote:
> I've just committed a change with new/improved assertion functions.
> These will be going into v0.6. The full set has now become:
>
> assertEqual: function (expected, actual, message)
> assertException: function (fn, message)
> assertFalse: function (actual, message)
> assertIdentical: function (expected, actual, message)
> assertInstanceOf: function (cls, actual, message)
> assertMatch: function (re, actual, message)
> assertNaN: function (actual, message)
> assertNotEqual: function (expected, actual, message)
> assertNotIdentical: function (expected, actual, message)
> assertNotInstanceOf: function (cls, actual, message)
> assertNotMatch: function (re, actual, message)
> assertNotNaN: function (actual, message)
> assertNotNull: function (actual, message)
> assertNotTypeOf: function (typ, actual, message)
> assertNotUndefined: function (actual, message)
> assertNull: function (actual, message)
> assertTrue: function (actual, message)
> assertTypeOf: function (typ, actual, message)
> assertUndefined: function (actual, message)
> fail: function (message)

I've opted not to have separate assert[Enum/Hash]Equal functions
because assertEqual does a lax comparison that can compare arrays/
objects through a rudimentary hash string. In contrast,
assertIndentical does a strict comparison. Here are the tests against
these functions to illustrate their behaviour:

function testAssertIdenticalPositive() {
a.assertIdentical(1, 1);
a.assertIdentical(null, null);
a.assertIdentical(undefined, undefined);
var obj = {};
a.assertIdentical(obj, obj);
}

function testAssertIdenticalNegative() {
a.assertException(function () {
a.assertIdentical(1, "1");
});
a.assertException(function () {
a.assertIdentical(null, undefined);
});
a.assertException(function () {
a.assertIdentical(false, 0);
});
}

function testAssertNotIdenticalPositive() {
a.assertNotIdentical("1", 1);
a.assertNotIdentical(undefined, null);
a.assertNotIdentical(1, true);
var obj1 = {};
var obj2 = {};
a.assertNotIdentical(obj1, obj2);
}

function testAssertNotIdenticalNegative() {
a.assertException(function () {
a.assertNotIdentical(1, 1);
});
a.assertException(function () {
a.assertNotIdentical(null, null);
});
a.assertException(function () {
a.assertNotIdentical(undefined, undefined);
});
var obj = {};
a.assertException(function () {
a.assertNotIdentical(obj, obj);
});
}

function testAssertEqualPositive() {
a.assertEqual(1, "1");
a.assertEqual({ a: 1, b: [ 2, 3 ] }, { a: 1, b: [ 2, 3 ] });
}

function testAssertEqualNegative() {
a.assertException(function () {
a.assertEqual("2", 1);
});
a.assertException(function () {
a.assertEqual({}, null);
});
a.assertException(function () {
a.assertEqual(undefined, null);
});
}

function testAssertNotEqualPositive() {
a.assertNotEqual(1, "2");
a.assertNotEqual(null, {});
}

function testAssertNotEqualNegative() {
a.assertException(function () {
a.assertNotEqual("2", 2);
});
a.assertException(function () {
a.assertNotEqual({ a: 1, b: [ 2, 3 ] }, { a: 1, b: [ 2,
3 ] });
});
}