Moved test-class into suite as Class/GeneralTest
This guy had some old tests indeed; it wasn't even in the second incarnation of the test formats! Flasback to the beginning of ease.js.perfodd
Mike Gerwitz
parent
f11b3b1f38
commit
ae367964a3
|
|
@ -0,0 +1,271 @@
|
|||
/**
|
||||
* Tests class module object creation
|
||||
*
|
||||
* Copyright (C) 2010, 2011, 2013 Mike Gerwitz
|
||||
*
|
||||
* This file is part of GNU ease.js.
|
||||
*
|
||||
* ease.js is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
|
||||
require( 'common' ).testCase(
|
||||
{
|
||||
setUp: function()
|
||||
{
|
||||
this.Sut = this.require( 'class' );
|
||||
|
||||
this.Foo = this.Sut.extend(
|
||||
{
|
||||
value: 'foo',
|
||||
} );
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* The most primitve means of creating a class is by calling the extend
|
||||
* method on the module itself, which will extend the base class. (Any
|
||||
* shorthand forms still do this.)
|
||||
*/
|
||||
'Class module should provide an extend method': function()
|
||||
{
|
||||
this.assertOk(
|
||||
typeof this.Sut.extend === 'function'
|
||||
);
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* The extend method should create a new constructor, which itself is a
|
||||
* function.
|
||||
*/
|
||||
'Extend method creates a new function': function()
|
||||
{
|
||||
this.assertOk( typeof this.Foo === 'function' );
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* Sanity check.
|
||||
*/
|
||||
'Classes are considered by the system to be classes': function()
|
||||
{
|
||||
this.assertOk( this.Sut.isClass( this.Foo ) );
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* Even though we have no problem working with conventional prototypes,
|
||||
* there may be certian features that ease.js provides in which it is
|
||||
* important to know whether or not the given object is a class created
|
||||
* with ease.js.
|
||||
*/
|
||||
'Only actual classes are considered to be classes': function()
|
||||
{
|
||||
this.assertOk( !( this.Sut.isClass( {} ) ) );
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* Class instances are objects, not classes.
|
||||
*/
|
||||
'Class instances are not considered to be classes': function()
|
||||
{
|
||||
var inst = new this.Foo();
|
||||
this.assertOk( !( this.Sut.isClass( inst ) ) );
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* ease.js may expose features that are useful only to instances of
|
||||
* classes created through ease.js, so it is useful to know when an
|
||||
* object is such.
|
||||
*/
|
||||
'Class instances are considered to be instances': function()
|
||||
{
|
||||
var inst = new this.Foo();
|
||||
this.assertOk( this.Sut.isClassInstance( inst ) );
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* An instance is, well, an instance of a class; it is not a class.
|
||||
*/
|
||||
'Classes are not considered to be class instances': function()
|
||||
{
|
||||
this.assertOk(
|
||||
( !( this.Sut.isClassInstance( this.Foo ) ) )
|
||||
);
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* While an object may be an instance of something in the traditional
|
||||
* ECMAScript sense, the distinction is important for the framework; you
|
||||
* don't need ease.js to determine if an object is an instance of
|
||||
* something that is non-ease.js-y.
|
||||
*/
|
||||
'Non-class objects are not considered to be instances': function()
|
||||
{
|
||||
// plain 'ol object
|
||||
this.assertOk( !( this.Sut.isClassInstance( {} ) ) );
|
||||
|
||||
// ctor instance
|
||||
var proto = function() {};
|
||||
this.assertOk( !( this.Sut.isClassInstance( new proto() ) ) );
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* A class shoudl be an immutable blueprint for creating objects. Unlike
|
||||
* prototypes, they should not be able to be modified at runtime to
|
||||
* affect every instance. If you want that, then use prototypes, not
|
||||
* classes.
|
||||
*/
|
||||
'Generated classes should be frozen': function()
|
||||
{
|
||||
// only perform check if supported by the engine
|
||||
if ( Object.isFrozen === undefined )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
this.assertOk( Object.isFrozen( this.Foo ) );
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* We provide a reflection mechanism that may be used to determine
|
||||
* whether an instance was created from a given class; this can be used
|
||||
* for typing.
|
||||
*/
|
||||
'Class instance is recognized as instance of class': function()
|
||||
{
|
||||
this.assertOk(
|
||||
this.Sut.isInstanceOf( this.Foo, new this.Foo() )
|
||||
);
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* We're talking about JS here; people do unpredictable things, and this
|
||||
* is likely to be a common one if type checking arguments to a
|
||||
* function/method.
|
||||
*/
|
||||
'Checking instance of undefined will not throw an error': function()
|
||||
{
|
||||
this.assertOk(
|
||||
this.Sut.isInstanceOf( this.Foo, undefined ) === false
|
||||
);
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* Similar to the above, but instead of providing undefined to be
|
||||
* checked against a class, the class to check against is undefined.
|
||||
*/
|
||||
'Checking for instance of undefined will not throw an error': function()
|
||||
{
|
||||
this.assertOk(
|
||||
this.Sut.isInstanceOf( undefined, {} ) === false
|
||||
);
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* Since a class is not an instance, it should never be recognized as an
|
||||
* instance of itself.
|
||||
*/
|
||||
'Class is not an instance of itself': function()
|
||||
{
|
||||
this.assertOk( !( this.Sut.isInstanceOf( this.Foo, this.Foo ) ) );
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* Sanity check...prevent confoundentry, which is particularily
|
||||
* important in the case of accidental argument order switching.
|
||||
*/
|
||||
'Class is not an instance of its instance': function()
|
||||
{
|
||||
this.assertOk(
|
||||
!( this.Sut.isInstanceOf( new this.Foo(), this.Foo ) )
|
||||
);
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* Sometimes it's easier to think in terms of types, not instances. This
|
||||
* is also shorter.
|
||||
*/
|
||||
'isA is an alias for isInstanceOf': function()
|
||||
{
|
||||
this.assertEqual(
|
||||
this.Sut.isInstanceOf,
|
||||
this.Sut.isA
|
||||
);
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* While more concise if used responsibly, it can also be dangerous in
|
||||
* the event that the instance may not be an ease.js class instance.
|
||||
*/
|
||||
'Class instance has partially applied isInstanceOf method': function()
|
||||
{
|
||||
var inst = new this.Foo();
|
||||
|
||||
this.assertOk(
|
||||
( ( typeof inst.isInstanceOf === 'function' )
|
||||
&& ( inst.isInstanceOf( this.Foo ) === true )
|
||||
&& ( inst.isInstanceOf( inst ) === false )
|
||||
)
|
||||
);
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* Same as above.
|
||||
*/
|
||||
'Class instance has partially applied isA alias method': function()
|
||||
{
|
||||
var inst = new this.Foo();
|
||||
|
||||
this.assertEqual(
|
||||
inst.isInstanceOf,
|
||||
inst.isA
|
||||
);
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* This really should be encapsulated, probably, but it does exist for
|
||||
* reference.
|
||||
*/
|
||||
'Class id is available via class': function()
|
||||
{
|
||||
this.assertOk( this.Foo.__cid !== undefined );
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* This ensures that the class id is accessible through all instances.
|
||||
*/
|
||||
'Class id is available via class prototype': function()
|
||||
{
|
||||
this.assertOk(
|
||||
( this.Foo.prototype.__cid !== undefined )
|
||||
);
|
||||
},
|
||||
} );
|
||||
|
|
@ -1,153 +0,0 @@
|
|||
/**
|
||||
* Tests class module object creation
|
||||
*
|
||||
* Copyright (C) 2010, 2011, 2013 Mike Gerwitz
|
||||
*
|
||||
* This file is part of GNU ease.js.
|
||||
*
|
||||
* ease.js is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
var common = require( './common' ),
|
||||
assert = require( 'assert' ),
|
||||
Class = common.require( 'class' );
|
||||
|
||||
|
||||
assert.ok(
|
||||
( Class.extend instanceof Function ),
|
||||
"Class module should provide an 'extend' method"
|
||||
);
|
||||
|
||||
|
||||
var Foo = Class.extend(
|
||||
{
|
||||
value: 'foo',
|
||||
});
|
||||
|
||||
|
||||
assert.ok(
|
||||
( Foo instanceof Object ),
|
||||
"Extend method creates a new object"
|
||||
);
|
||||
|
||||
assert.ok(
|
||||
( Class.isClass( Class.extend() ) ),
|
||||
"Classes are considered by the system to be classes"
|
||||
);
|
||||
|
||||
|
||||
var inst = new Foo();
|
||||
|
||||
|
||||
//
|
||||
// isClass
|
||||
assert.ok(
|
||||
( !( Class.isClass( {} ) ) ),
|
||||
"Only actual classes are considered to be classes"
|
||||
);
|
||||
|
||||
assert.ok(
|
||||
!( Class.isClass( inst ) ),
|
||||
"Class instances are not considered to be classes (they are objects)"
|
||||
);
|
||||
|
||||
|
||||
//
|
||||
// isClassInstance
|
||||
assert.ok(
|
||||
( Class.isClassInstance( inst ) ),
|
||||
"Class instances are considered to be classes instances"
|
||||
);
|
||||
|
||||
assert.ok(
|
||||
( !( Class.isClassInstance( Foo ) ) ),
|
||||
"Classes are not considered to be class instances"
|
||||
);
|
||||
|
||||
assert.ok(
|
||||
( !( Class.isClassInstance( {} ) ) ),
|
||||
"Other objects are not considered to be class instances"
|
||||
);
|
||||
|
||||
|
||||
// only perform check if supported by the engine
|
||||
if ( Object.isFrozen )
|
||||
{
|
||||
assert.equal(
|
||||
Object.isFrozen( Foo ),
|
||||
true,
|
||||
"Generated class should be frozen"
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// isInstanceOf
|
||||
assert.ok(
|
||||
Class.isInstanceOf( Foo, inst ),
|
||||
"Class instance is recognized by Class.isInstanceOf()"
|
||||
);
|
||||
|
||||
assert.ok(
|
||||
Class.isInstanceOf( Foo, undefined ) === false,
|
||||
"Checking instance of undefined will not throw an error"
|
||||
);
|
||||
|
||||
assert.ok(
|
||||
Class.isInstanceOf( undefined, {} ) === false,
|
||||
"Checking for instance of undefined will not throw an error"
|
||||
);
|
||||
|
||||
assert.ok(
|
||||
!( Class.isInstanceOf( Foo, Foo ) ),
|
||||
"Class is not an instance of itself when uninstantiated"
|
||||
);
|
||||
|
||||
assert.ok(
|
||||
!( Class.isInstanceOf( inst, Foo ) ),
|
||||
"Class is not an instance of its instance"
|
||||
);
|
||||
|
||||
assert.equal(
|
||||
Class.isInstanceOf,
|
||||
Class.isA,
|
||||
"isA() is an alias for isInstanceOf()"
|
||||
);
|
||||
|
||||
assert.ok(
|
||||
( ( inst.isInstanceOf instanceof Function )
|
||||
&& ( inst.isInstanceOf( Foo ) === true )
|
||||
&& ( inst.isInstanceOf( inst ) === false )
|
||||
),
|
||||
"Class instance contains partially applied isInstanceOf method"
|
||||
);
|
||||
|
||||
assert.equal(
|
||||
inst.isInstanceOf,
|
||||
inst.isA,
|
||||
"Class instance contains isA() alias for isInstanceOf() partially applied function"
|
||||
);
|
||||
|
||||
|
||||
|
||||
assert.ok(
|
||||
( Foo.__cid !== undefined ),
|
||||
"Class id available via class"
|
||||
);
|
||||
|
||||
assert.ok(
|
||||
( Foo.prototype.__cid !== undefined ),
|
||||
"Class id available via class prototype"
|
||||
);
|
||||
|
||||
Loading…
Reference in New Issue