Moved test-class-extend into suite as Class/{Extend,InstanceSafety}Test
More refactoring to come for ExtendTest at some pointperfodd
Mike Gerwitz
parent
ae367964a3
commit
2b5bcaf02d
|
|
@ -0,0 +1,431 @@
|
||||||
|
/**
|
||||||
|
* Tests class module extend() method
|
||||||
|
*
|
||||||
|
* 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/>.
|
||||||
|
*
|
||||||
|
* Note that these tests all use the `new' keyword for instantiating
|
||||||
|
* classes, even though it is not required with ease.js; this is both for
|
||||||
|
* historical reasons (when `new' was required during early development) and
|
||||||
|
* because we are not testing (and do want to depend upon) that feature.
|
||||||
|
*/
|
||||||
|
|
||||||
|
require( 'common' ).testCase(
|
||||||
|
{
|
||||||
|
caseSetUp: function()
|
||||||
|
{
|
||||||
|
this.test_props = {
|
||||||
|
one: 1,
|
||||||
|
two: 2,
|
||||||
|
};
|
||||||
|
|
||||||
|
this.Sut = this.require( 'class' );
|
||||||
|
|
||||||
|
// there are two different means of extending; we want to test them
|
||||||
|
// both (this will be denoted Foo)
|
||||||
|
this.classes = [
|
||||||
|
this.Sut.extend( this.test_props ),
|
||||||
|
this.Sut( this.test_props ),
|
||||||
|
];
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* All classes can be easily extended via an extend method, although it
|
||||||
|
* is not necessarily recommended to be used directly, as you must
|
||||||
|
* ensure that the object is an ease.js class and the resulting class
|
||||||
|
* will be anonymous.
|
||||||
|
*/
|
||||||
|
'@each(classes) Created class contains extend method': function( C )
|
||||||
|
{
|
||||||
|
this.assertOk( typeof C.extend === 'function' );
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* It would make sense that a subtype returned is an object, since it
|
||||||
|
* cannot be a class if it isn't.
|
||||||
|
*/
|
||||||
|
'@each(classes) Subtype is returned as an object': function( C )
|
||||||
|
{
|
||||||
|
this.assertOk( C.extend() instanceof Object );
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Subtypes should inherit all properties of the supertype into their
|
||||||
|
* prototype chain.
|
||||||
|
*/
|
||||||
|
'@each(classes) Subtype inherits parent properties': function( C )
|
||||||
|
{
|
||||||
|
var SubFoo = C.extend();
|
||||||
|
|
||||||
|
for ( var prop in this.test_props )
|
||||||
|
{
|
||||||
|
this.assertEqual(
|
||||||
|
this.test_props[ prop ],
|
||||||
|
SubFoo.prototype[ prop ],
|
||||||
|
"Missing property: " + prop
|
||||||
|
);
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A subtype should obvious contain the properties that were a part of
|
||||||
|
* its definition.
|
||||||
|
*/
|
||||||
|
'@each(classes) Subtype contains its own properties': function( C )
|
||||||
|
{
|
||||||
|
var sub_props = {
|
||||||
|
three: 3,
|
||||||
|
four: 4,
|
||||||
|
};
|
||||||
|
|
||||||
|
var sub_foo = new C.extend( sub_props )();
|
||||||
|
|
||||||
|
// and ensure that the subtype's properties were included
|
||||||
|
for ( var prop in sub_props )
|
||||||
|
{
|
||||||
|
this.assertEqual(
|
||||||
|
sub_props[ prop ],
|
||||||
|
sub_foo[ prop ],
|
||||||
|
"Missing property: " + prop
|
||||||
|
);
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* In addition to the core functions provided by ease.js for checking
|
||||||
|
* instances, we try to ease into the protype model the best we can in
|
||||||
|
* order to work with other prototypes; therefore, instances should be
|
||||||
|
* recognized as instances of their parent classes even by the
|
||||||
|
* ECMAScript `instanceof' operator.
|
||||||
|
*/
|
||||||
|
'@each(classes) Subtypes are ECMAScript instances of their supertypes':
|
||||||
|
function( C )
|
||||||
|
{
|
||||||
|
this.assertOk( C.extend()() instanceof C );
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Even though this can be checked using the instanceof operator,
|
||||||
|
* ease.js has a more complex type system (e.g. supporting of
|
||||||
|
* interfaces) and so we want to provide a consistent alternative.
|
||||||
|
*/
|
||||||
|
'@each(classes) Subtypes are easejs instances of their supertypes':
|
||||||
|
function( C )
|
||||||
|
{
|
||||||
|
var SubFoo = C.extend(),
|
||||||
|
sub_instance = new SubFoo();
|
||||||
|
|
||||||
|
this.assertOk( sub_instance.isInstanceOf( SubFoo ) );
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Foo
|
||||||
|
* |
|
||||||
|
* SubFoo
|
||||||
|
* / \
|
||||||
|
* SubSubFoo SubSubFoo2
|
||||||
|
*
|
||||||
|
/
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Objects should be considered instances of any classes that their
|
||||||
|
* instantiating class inherits from, since they inherit their API and
|
||||||
|
* are interchangable, provided that only the common subset of the API
|
||||||
|
* is used.
|
||||||
|
*/
|
||||||
|
'@each(classes) Objects are instances of their super-supertypes':
|
||||||
|
function( C )
|
||||||
|
{
|
||||||
|
var sub_sub_instance = new ( C.extend().extend() )();
|
||||||
|
|
||||||
|
this.assertOk(
|
||||||
|
( ( sub_sub_instance instanceof C )
|
||||||
|
&& sub_sub_instance.isInstanceOf( C )
|
||||||
|
)
|
||||||
|
);
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* It would not make sense that an object is considered to be an
|
||||||
|
* instance of any possible subtypes---that is, if C inherits B, then an
|
||||||
|
* instance of B is not of type C; C could introduce an incompatible
|
||||||
|
* interface.
|
||||||
|
*/
|
||||||
|
'@each(classes) Objects are not instances of subtypes': function( C )
|
||||||
|
{
|
||||||
|
var SubFoo = C.extend(),
|
||||||
|
SubSubFoo = SubFoo.extend(),
|
||||||
|
sub_inst = new SubFoo();
|
||||||
|
|
||||||
|
this.assertOk(
|
||||||
|
( !( sub_inst instanceof SubSubFoo )
|
||||||
|
&& !( sub_inst.isInstanceOf( SubSubFoo ) )
|
||||||
|
)
|
||||||
|
);
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Two classes that inherit from a common parent are not compatible, as
|
||||||
|
* they can introduce their own distinct interfaces.
|
||||||
|
*/
|
||||||
|
'@each(classes) Objects are not instances of sibling types':
|
||||||
|
function( C )
|
||||||
|
{
|
||||||
|
var SubFoo = C.extend(),
|
||||||
|
SubSubFoo = SubFoo.extend(),
|
||||||
|
SubSubFoo2 = SubFoo.extend(),
|
||||||
|
|
||||||
|
sub_sub2_inst = new SubSubFoo2();
|
||||||
|
|
||||||
|
this.assertOk(
|
||||||
|
( !( sub_sub2_inst instanceof SubSubFoo )
|
||||||
|
&& !( sub_sub2_inst.isInstanceOf( SubSubFoo ) )
|
||||||
|
)
|
||||||
|
);
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* We support extending existing prototypes (that is, inherit from
|
||||||
|
* constructors that were not created using ease.js).
|
||||||
|
*/
|
||||||
|
'Constructor prototype is copied to subclass': function()
|
||||||
|
{
|
||||||
|
var Ctor = function() {};
|
||||||
|
Ctor.prototype = { foo: {} };
|
||||||
|
|
||||||
|
this.assertStrictEqual(
|
||||||
|
this.Sut.extend( Ctor, {} ).prototype.foo,
|
||||||
|
Ctor.prototype.foo
|
||||||
|
);
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* This should go without saying---we're aiming for consistency here and
|
||||||
|
* subclassing doesn't make much sense if it doesn't work.
|
||||||
|
*/
|
||||||
|
'Subtype of constructor should contain extended members': function()
|
||||||
|
{
|
||||||
|
var Ctor = function() {};
|
||||||
|
|
||||||
|
this.assertNotEqual(
|
||||||
|
( new this.Sut.extend( Ctor, { foo: {} } )() ).foo,
|
||||||
|
undefined
|
||||||
|
);
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* If a subtype provides a property of the same name as its parent, then
|
||||||
|
* it should act as a reassignment.
|
||||||
|
*/
|
||||||
|
'Subtypes can override parent property values': function()
|
||||||
|
{
|
||||||
|
var expect = 'ok',
|
||||||
|
C = this.Sut.extend( { p: null } ).extend( { p: expect } );
|
||||||
|
|
||||||
|
this.assertEqual( C().p, expect );
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Prevent overriding the internal method that initializes property
|
||||||
|
* values upon instantiation.
|
||||||
|
*/
|
||||||
|
'__initProps() cannot be declared (internal method)': function()
|
||||||
|
{
|
||||||
|
var _self = this;
|
||||||
|
|
||||||
|
this.assertThrows( function()
|
||||||
|
{
|
||||||
|
_self.Sut.extend(
|
||||||
|
{
|
||||||
|
__initProps: function() {},
|
||||||
|
} );
|
||||||
|
}, Error );
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
// TODO: move me into a more appropriate test case (this may actually be
|
||||||
|
// tested elsewhere)
|
||||||
|
/**
|
||||||
|
* If using the short-hand extend, an object is required to represent
|
||||||
|
* the class defintiion.
|
||||||
|
*/
|
||||||
|
'Invoking class module requires object as argument if extending':
|
||||||
|
function()
|
||||||
|
{
|
||||||
|
var _self = this;
|
||||||
|
|
||||||
|
// these tests can be run in the browser in pre-ES5 environments, so
|
||||||
|
// no forEach()
|
||||||
|
var chk = [ 5, false, undefined ],
|
||||||
|
i = chk.length;
|
||||||
|
|
||||||
|
while ( i-- )
|
||||||
|
{
|
||||||
|
this.assertThrows( function()
|
||||||
|
{
|
||||||
|
_self.Sut( chk[ i ] );
|
||||||
|
},
|
||||||
|
TypeError
|
||||||
|
);
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* We provide a useful default toString() method, but one may wish to
|
||||||
|
* override it
|
||||||
|
*/
|
||||||
|
'Can override toString() method': function()
|
||||||
|
{
|
||||||
|
var str = 'foomookittypoo',
|
||||||
|
result = ''
|
||||||
|
;
|
||||||
|
|
||||||
|
result = this.Sut( 'FooToStr',
|
||||||
|
{
|
||||||
|
toString: function()
|
||||||
|
{
|
||||||
|
return str;
|
||||||
|
},
|
||||||
|
} )().toString();
|
||||||
|
|
||||||
|
this.assertEqual( result, str );
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* In ease.js's initial design, keywords were not included. This meant
|
||||||
|
* that duplicate member definitions were not possible---it'd throw a
|
||||||
|
* parse error (maybe). However, with keywords, it is now possible to
|
||||||
|
* redeclare a member with the same name in the same class definition.
|
||||||
|
* Since this doesn't make much sense, we must disallow it.
|
||||||
|
*/
|
||||||
|
'Cannot provide duplicate member definitions using unique keys':
|
||||||
|
function()
|
||||||
|
{
|
||||||
|
var _self = this;
|
||||||
|
|
||||||
|
this.assertThrows( function()
|
||||||
|
{
|
||||||
|
_self.Sut(
|
||||||
|
{
|
||||||
|
// declare as protected first so that we won't get a visibility
|
||||||
|
// de-escalation error with the below re-definition
|
||||||
|
'protected foo': '',
|
||||||
|
|
||||||
|
// should fail; redefinition
|
||||||
|
'public foo': '',
|
||||||
|
} );
|
||||||
|
}, Error );
|
||||||
|
|
||||||
|
this.assertThrows( function()
|
||||||
|
{
|
||||||
|
_self.Sut(
|
||||||
|
{
|
||||||
|
// declare as protected first so that we won't get a visibility
|
||||||
|
// de-escalation error with the below re-definition
|
||||||
|
'protected foo': function() {},
|
||||||
|
|
||||||
|
// should fail; redefinition
|
||||||
|
'public foo': function() {},
|
||||||
|
} );
|
||||||
|
}, Error );
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* To understand this test, one must understand how "inheritance" works
|
||||||
|
* with prototypes. We must create a new instance of the ctor (class)
|
||||||
|
* and add that instance to the prototype chain (if we added an
|
||||||
|
* un-instantiated constructor, then the members in the prototype would
|
||||||
|
* be accessible only though ctor.prototype). Therefore, when we
|
||||||
|
* instantiate this class for use in the prototype, we must ensure the
|
||||||
|
* constructor is not invoked, since our intent is not to create a new
|
||||||
|
* instance of the class.
|
||||||
|
*/
|
||||||
|
'__construct should not be called when extending class': function()
|
||||||
|
{
|
||||||
|
var called = false,
|
||||||
|
Foo = this.Sut( {
|
||||||
|
'public __construct': function()
|
||||||
|
{
|
||||||
|
called = true;
|
||||||
|
}
|
||||||
|
} ).extend( {} );
|
||||||
|
|
||||||
|
this.assertEqual( called, false );
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Previously, when attempting to extend from an invalid supertype,
|
||||||
|
* you'd get a CALL_NON_FUNCTION_AS_CONSTRUCTOR error, which is not very
|
||||||
|
* helpful to someone who is not familiar with the ease.js internals.
|
||||||
|
* Let's provide a more useful error that clearly states what's going
|
||||||
|
* on.
|
||||||
|
*/
|
||||||
|
'Extending from non-ctor or non-class provides useful error': function()
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
// invalid supertype
|
||||||
|
this.Sut.extend( 'oops', {} );
|
||||||
|
}
|
||||||
|
catch ( e )
|
||||||
|
{
|
||||||
|
this.assertOk( e.message.search( 'extend from' ),
|
||||||
|
"Error message for extending from non-ctor or class " +
|
||||||
|
"makes sense"
|
||||||
|
);
|
||||||
|
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
this.assertFail(
|
||||||
|
"Attempting to extend from non-ctor or class should " +
|
||||||
|
"throw exception"
|
||||||
|
);
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* If we attempt to extend an object (rather than a constructor), we
|
||||||
|
* should simply use that as the prototype directly rather than
|
||||||
|
* attempting to instantiate it.
|
||||||
|
*/
|
||||||
|
'Extending object will not attempt instantiation': function()
|
||||||
|
{
|
||||||
|
var obj = { foo: 'bar' };
|
||||||
|
|
||||||
|
this.assertEqual( obj.foo, this.Sut.extend( obj, {} )().foo,
|
||||||
|
"Should be able to use object as prototype"
|
||||||
|
);
|
||||||
|
},
|
||||||
|
} );
|
||||||
|
|
@ -0,0 +1,87 @@
|
||||||
|
/**
|
||||||
|
* Tests safety of class instances
|
||||||
|
*
|
||||||
|
* Copyright (C) 2010, 2011, 2013, 2014 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(
|
||||||
|
{
|
||||||
|
caseSetUp: function()
|
||||||
|
{
|
||||||
|
this.Sut = this.require( 'class' );
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Ensure that we're not getting/setting values of the prototype, which
|
||||||
|
* would have disasterous implications (=== can also be used to test for
|
||||||
|
* references, but this test demonstrates the functionality that we're
|
||||||
|
* looking to ensure)
|
||||||
|
*/
|
||||||
|
'Multiple instances of same class do not share array references':
|
||||||
|
function()
|
||||||
|
{
|
||||||
|
var C = this.Sut.extend( { arr: [] } ),
|
||||||
|
obj1 = new C(),
|
||||||
|
obj2 = new C();
|
||||||
|
|
||||||
|
obj1.arr.push( 'one' );
|
||||||
|
obj2.arr.push( 'two' );
|
||||||
|
|
||||||
|
// if the arrays are distinct, then each will have only one element
|
||||||
|
this.assertEqual( obj1.arr[ 0 ], 'one' );
|
||||||
|
this.assertEqual( obj2.arr[ 0 ], 'two' );
|
||||||
|
this.assertEqual( obj1.arr.length, 1 );
|
||||||
|
this.assertEqual( obj2.arr.length, 1 );
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Same concept as above, but with objects instead of arrays.
|
||||||
|
*/
|
||||||
|
'Multiple instances of same class do not share object references':
|
||||||
|
function()
|
||||||
|
{
|
||||||
|
var C = this.Sut.extend( { obj: {} } ),
|
||||||
|
obj1 = new C(),
|
||||||
|
obj2 = new C();
|
||||||
|
|
||||||
|
obj1.obj.a = true;
|
||||||
|
obj2.obj.b = true;
|
||||||
|
|
||||||
|
this.assertEqual( obj1.obj.a, true );
|
||||||
|
this.assertEqual( obj1.obj.b, undefined );
|
||||||
|
|
||||||
|
this.assertEqual( obj2.obj.a, undefined );
|
||||||
|
this.assertEqual( obj2.obj.b, true );
|
||||||
|
},
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Ensure that the above checks extend to subtypes.
|
||||||
|
*/
|
||||||
|
'Instances of subtypes do not share property references': function()
|
||||||
|
{
|
||||||
|
var C2 = this.Sut.extend( { arr: [], obj: {} } ).extend( {} ),
|
||||||
|
obj1 = new C2(),
|
||||||
|
obj2 = new C2();
|
||||||
|
|
||||||
|
this.assertNotEqual( obj1.arr !== obj2.arr );
|
||||||
|
this.assertNotEqual( obj1.obj !== obj2.obj );
|
||||||
|
},
|
||||||
|
} );
|
||||||
|
|
@ -116,6 +116,11 @@ module.exports = function( test_case )
|
||||||
|
|
||||||
if ( method === 'each' )
|
if ( method === 'each' )
|
||||||
{
|
{
|
||||||
|
if ( !( context[ prop ] ) )
|
||||||
|
{
|
||||||
|
throw Error( "Unknown @each context: " + prop );
|
||||||
|
}
|
||||||
|
|
||||||
count = context[ prop ].length;
|
count = context[ prop ].length;
|
||||||
args = [];
|
args = [];
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -1,463 +0,0 @@
|
||||||
/**
|
|
||||||
* Tests class module extend() method
|
|
||||||
*
|
|
||||||
* 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' );
|
|
||||||
|
|
||||||
var foo_props = {
|
|
||||||
one: 1,
|
|
||||||
two: 2,
|
|
||||||
},
|
|
||||||
|
|
||||||
// there are two different means of extending; we want to test them both
|
|
||||||
classes = [
|
|
||||||
Class.extend( foo_props ),
|
|
||||||
Class( foo_props ),
|
|
||||||
],
|
|
||||||
|
|
||||||
class_count = classes.length,
|
|
||||||
|
|
||||||
// will hold the class being tested
|
|
||||||
Foo = null
|
|
||||||
;
|
|
||||||
|
|
||||||
|
|
||||||
// Run all tests for both. This will ensure that, regardless of how the class is
|
|
||||||
// created, it operates as it should. Fortunately, these tests are fairly quick.
|
|
||||||
for ( var i = 0; i < class_count; i++ )
|
|
||||||
{
|
|
||||||
Foo = classes[ i ];
|
|
||||||
|
|
||||||
assert.ok(
|
|
||||||
( Foo.extend instanceof Function ),
|
|
||||||
"Created class contains extend method"
|
|
||||||
);
|
|
||||||
|
|
||||||
var sub_props = {
|
|
||||||
three: 3,
|
|
||||||
four: 4,
|
|
||||||
},
|
|
||||||
|
|
||||||
SubFoo = Foo.extend( sub_props ),
|
|
||||||
sub_foo = SubFoo()
|
|
||||||
;
|
|
||||||
|
|
||||||
assert.ok(
|
|
||||||
( SubFoo instanceof Object ),
|
|
||||||
"Subtype is returned as an object"
|
|
||||||
);
|
|
||||||
|
|
||||||
// ensure properties were inherited from supertype
|
|
||||||
for ( var prop in foo_props )
|
|
||||||
{
|
|
||||||
assert.equal(
|
|
||||||
foo_props[ prop ],
|
|
||||||
SubFoo.prototype[ prop ],
|
|
||||||
"Subtype inherits parent properties: " + prop
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
// and ensure that the subtype's properties were included
|
|
||||||
for ( var prop in sub_props )
|
|
||||||
{
|
|
||||||
assert.equal(
|
|
||||||
sub_props[ prop ],
|
|
||||||
sub_foo[ prop ],
|
|
||||||
"Subtype contains its own properties: " + prop
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
var sub_instance = new SubFoo();
|
|
||||||
|
|
||||||
assert.ok(
|
|
||||||
( sub_instance instanceof Foo ),
|
|
||||||
"Subtypes are considered to be instances of their supertypes " +
|
|
||||||
"(via instanceof operator)"
|
|
||||||
);
|
|
||||||
|
|
||||||
assert.ok(
|
|
||||||
sub_instance.isInstanceOf( SubFoo ),
|
|
||||||
"Subtypes are considered to be instances of their supertypes (via " +
|
|
||||||
"isInstanceOf method)"
|
|
||||||
);
|
|
||||||
|
|
||||||
|
|
||||||
// Foo
|
|
||||||
// |
|
|
||||||
// SubFoo
|
|
||||||
// / \
|
|
||||||
// SubSubFoo SubSubFoo2
|
|
||||||
//
|
|
||||||
var SubSubFoo = SubFoo.extend(),
|
|
||||||
SubSubFoo2 = SubFoo.extend(),
|
|
||||||
|
|
||||||
sub_sub_instance = new SubSubFoo(),
|
|
||||||
sub_sub2_instance = new SubSubFoo2();
|
|
||||||
|
|
||||||
assert.ok(
|
|
||||||
( ( sub_sub_instance instanceof Foo )
|
|
||||||
&& sub_sub_instance.isInstanceOf( Foo )
|
|
||||||
),
|
|
||||||
"Sub-subtypes should be instances of their super-supertype"
|
|
||||||
);
|
|
||||||
|
|
||||||
assert.ok(
|
|
||||||
( !( sub_instance instanceof SubSubFoo )
|
|
||||||
&& !( sub_instance.isInstanceOf( SubSubFoo ) )
|
|
||||||
),
|
|
||||||
"Supertypes should not be considered instances of their subtypes"
|
|
||||||
);
|
|
||||||
|
|
||||||
assert.ok(
|
|
||||||
( !( sub_sub2_instance instanceof SubSubFoo )
|
|
||||||
&& !( sub_sub2_instance.isInstanceOf( SubSubFoo ) )
|
|
||||||
),
|
|
||||||
"Subtypes should not be considered instances of their siblings"
|
|
||||||
);
|
|
||||||
|
|
||||||
|
|
||||||
// to test inheritance of classes that were not previously created via the
|
|
||||||
// Class.extend() method
|
|
||||||
var OtherClass = function() {};
|
|
||||||
OtherClass.prototype =
|
|
||||||
{
|
|
||||||
foo: 'bla',
|
|
||||||
};
|
|
||||||
|
|
||||||
var SubOther = Class.extend( OtherClass,
|
|
||||||
{
|
|
||||||
newFoo: 2,
|
|
||||||
});
|
|
||||||
|
|
||||||
|
|
||||||
assert.equal(
|
|
||||||
SubOther.prototype.foo,
|
|
||||||
OtherClass.prototype.foo,
|
|
||||||
"Prototype of existing class should be copied to subclass"
|
|
||||||
);
|
|
||||||
|
|
||||||
assert.notEqual(
|
|
||||||
SubOther().newFoo,
|
|
||||||
undefined,
|
|
||||||
"Subtype should contain extended members"
|
|
||||||
);
|
|
||||||
|
|
||||||
|
|
||||||
assert['throws']( function()
|
|
||||||
{
|
|
||||||
Class.extend( OtherClass,
|
|
||||||
{
|
|
||||||
foo: function() {},
|
|
||||||
});
|
|
||||||
}, TypeError, "Cannot override property with a method" );
|
|
||||||
|
|
||||||
|
|
||||||
var AnotherFoo = Class.extend(
|
|
||||||
{
|
|
||||||
arr: [],
|
|
||||||
obj: {},
|
|
||||||
});
|
|
||||||
|
|
||||||
var Obj1 = new AnotherFoo(),
|
|
||||||
Obj2 = new AnotherFoo();
|
|
||||||
|
|
||||||
Obj1.arr.push( 'one' );
|
|
||||||
Obj2.arr.push( 'two' );
|
|
||||||
|
|
||||||
Obj1.obj.a = true;
|
|
||||||
Obj2.obj.b = true;
|
|
||||||
|
|
||||||
// to ensure we're not getting/setting values of the prototype (=== can also be
|
|
||||||
// used to test for references, but this test demonstrates the functionality
|
|
||||||
// that we're looking to ensure)
|
|
||||||
assert.ok(
|
|
||||||
( ( Obj1.arr[ 0 ] === 'one' ) && ( Obj2.arr[ 0 ] === 'two' ) ),
|
|
||||||
"Multiple instances of the same class do not share array references"
|
|
||||||
);
|
|
||||||
|
|
||||||
assert.ok(
|
|
||||||
( ( ( Obj1.obj.a === true ) && ( Obj1.obj.b === undefined ) )
|
|
||||||
&& ( ( Obj2.obj.a === undefined ) && ( Obj2.obj.b === true ) )
|
|
||||||
),
|
|
||||||
"Multiple instances of the same class do not share object references"
|
|
||||||
);
|
|
||||||
|
|
||||||
var arr_val = 1;
|
|
||||||
var SubAnotherFoo = AnotherFoo.extend(
|
|
||||||
{
|
|
||||||
arr: [ arr_val ],
|
|
||||||
});
|
|
||||||
|
|
||||||
var SubObj1 = new SubAnotherFoo(),
|
|
||||||
SubObj2 = new SubAnotherFoo();
|
|
||||||
|
|
||||||
assert.ok(
|
|
||||||
( ( SubObj1.arr !== SubObj2.arr ) && ( SubObj1.obj !== SubObj2.obj ) ),
|
|
||||||
"Instances of subtypes do not share property references"
|
|
||||||
);
|
|
||||||
|
|
||||||
assert.ok(
|
|
||||||
( ( SubObj1.arr[ 0 ] === arr_val ) && ( SubObj2.arr[ 0 ] === arr_val ) ),
|
|
||||||
"Subtypes can override parent property values"
|
|
||||||
);
|
|
||||||
|
|
||||||
assert['throws']( function()
|
|
||||||
{
|
|
||||||
Class.extend(
|
|
||||||
{
|
|
||||||
__initProps: function() {},
|
|
||||||
});
|
|
||||||
}, Error, "__initProps() cannot be declared (internal method)" );
|
|
||||||
|
|
||||||
|
|
||||||
var SubSubAnotherFoo = AnotherFoo.extend(),
|
|
||||||
SubSubObj1 = new SubSubAnotherFoo(),
|
|
||||||
SubSubObj2 = new SubSubAnotherFoo();
|
|
||||||
|
|
||||||
// to ensure the effect is recursive
|
|
||||||
assert.ok(
|
|
||||||
( ( SubSubObj1.arr !== SubSubObj2.arr )
|
|
||||||
&& ( SubSubObj1.obj !== SubSubObj2.obj )
|
|
||||||
),
|
|
||||||
"Instances of subtypes do not share property references"
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
( function testInvokingClassModuleRequiresObjectAsArgumentIfCreating()
|
|
||||||
{
|
|
||||||
assert['throws']( function()
|
|
||||||
{
|
|
||||||
Class( 'moo' );
|
|
||||||
Class( 5 );
|
|
||||||
Class( false );
|
|
||||||
Class();
|
|
||||||
},
|
|
||||||
TypeError,
|
|
||||||
"Invoking class module requires object as argument if extending " +
|
|
||||||
"from base class"
|
|
||||||
);
|
|
||||||
|
|
||||||
var args = [ {}, 'one', 'two', 'three' ];
|
|
||||||
|
|
||||||
// we must only provide one argument if the first argument is an object (the
|
|
||||||
// class definition)
|
|
||||||
try
|
|
||||||
{
|
|
||||||
Class.apply( null, args );
|
|
||||||
|
|
||||||
// if all goes well, we don't get to this line
|
|
||||||
assert.fail(
|
|
||||||
"Only one argument for class definitions is permitted"
|
|
||||||
);
|
|
||||||
}
|
|
||||||
catch ( e )
|
|
||||||
{
|
|
||||||
assert.notEqual(
|
|
||||||
e.message.match( args.length + ' given' ),
|
|
||||||
null,
|
|
||||||
"Class invocation should give argument count on error"
|
|
||||||
);
|
|
||||||
}
|
|
||||||
} )();
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* We provide a useful default toString() method, but one may wish to override
|
|
||||||
* it
|
|
||||||
*/
|
|
||||||
( function testCanOverrideToStringMethod()
|
|
||||||
{
|
|
||||||
var str = 'foomookittypoo',
|
|
||||||
result = ''
|
|
||||||
;
|
|
||||||
|
|
||||||
result = Class( 'FooToStr',
|
|
||||||
{
|
|
||||||
toString: function()
|
|
||||||
{
|
|
||||||
return str;
|
|
||||||
},
|
|
||||||
bla: function() {},
|
|
||||||
})().toString();
|
|
||||||
|
|
||||||
assert.equal(
|
|
||||||
result,
|
|
||||||
str,
|
|
||||||
"Can override default toString() method of class"
|
|
||||||
);
|
|
||||||
} )();
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* In ease.js's initial design, keywords were not included. This meant that
|
|
||||||
* duplicate member definitions were not possible - it'd throw a parse error.
|
|
||||||
* However, with keywords, it is now possible to redeclare a member with the
|
|
||||||
* same name in the same class definition. Since this doesn't make much sense,
|
|
||||||
* we must disallow it.
|
|
||||||
*/
|
|
||||||
( function testCannotProvideDuplicateMemberDefintions()
|
|
||||||
{
|
|
||||||
assert['throws']( function()
|
|
||||||
{
|
|
||||||
Class(
|
|
||||||
{
|
|
||||||
// declare as protected first so that we won't get a visibility
|
|
||||||
// de-escalation error with the below re-definition
|
|
||||||
'protected foo': '',
|
|
||||||
|
|
||||||
// should fail; redefinition
|
|
||||||
'public foo': '',
|
|
||||||
} );
|
|
||||||
}, Error, "Cannot redeclare property in same class definition" );
|
|
||||||
|
|
||||||
assert['throws']( function()
|
|
||||||
{
|
|
||||||
Class(
|
|
||||||
{
|
|
||||||
// declare as protected first so that we won't get a visibility
|
|
||||||
// de-escalation error with the below re-definition
|
|
||||||
'protected foo': function() {},
|
|
||||||
|
|
||||||
// should fail; redefinition
|
|
||||||
'public foo': function() {},
|
|
||||||
} );
|
|
||||||
}, Error, "Cannot redeclare method in same class definition" );
|
|
||||||
} )();
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* To understand this test, one must understand how "inheritance" works
|
|
||||||
* with prototypes. We must create a new instance of the ctor (class) and add
|
|
||||||
* that instance to the prototype chain (if we added an un-instantiated
|
|
||||||
* constructor, then the members in the prototype would be accessible only
|
|
||||||
* though ctor.prototype). Therefore, when we instantiate this class for use in
|
|
||||||
* the prototype, we must ensure the constructor is not invoked, since our
|
|
||||||
* intent is not to create a new instance of the class.
|
|
||||||
*/
|
|
||||||
( function testConstructorShouldNotBeCalledWhenExtendingClass()
|
|
||||||
{
|
|
||||||
var called = false,
|
|
||||||
Foo = Class( {
|
|
||||||
'public __construct': function()
|
|
||||||
{
|
|
||||||
called = true;
|
|
||||||
}
|
|
||||||
} ).extend( {} );
|
|
||||||
|
|
||||||
assert.equal( called, false,
|
|
||||||
"Constructor should not be called when extending a class"
|
|
||||||
);
|
|
||||||
} )();
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Previously, when attempting to extend from an invalid supertype, you'd get a
|
|
||||||
* CALL_NON_FUNCTION_AS_CONSTRUCTOR error, which is not very helpful to someone
|
|
||||||
* who is not familiar with the ease.js internals. Let's provide a more useful
|
|
||||||
* error that clearly states what's going on.
|
|
||||||
*/
|
|
||||||
( function testExtendingFromNonCtorOrClassProvidesUsefulError()
|
|
||||||
{
|
|
||||||
try
|
|
||||||
{
|
|
||||||
// invalid supertype
|
|
||||||
Class.extend( 'oops', {} );
|
|
||||||
}
|
|
||||||
catch ( e )
|
|
||||||
{
|
|
||||||
assert.ok( e.message.search( 'extend from' ),
|
|
||||||
"Error message for extending from non-ctor or class makes sense"
|
|
||||||
);
|
|
||||||
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
assert.fail(
|
|
||||||
"Attempting to extend from non-ctor or class should throw exception"
|
|
||||||
);
|
|
||||||
} )();
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Only virtual methods may be overridden.
|
|
||||||
*/
|
|
||||||
( function testCannotOverrideNonVirtualMethod()
|
|
||||||
{
|
|
||||||
try
|
|
||||||
{
|
|
||||||
var Foo = Class(
|
|
||||||
{
|
|
||||||
// non-virtual
|
|
||||||
'public foo': function() {},
|
|
||||||
} ),
|
|
||||||
|
|
||||||
SubFoo = Foo.extend(
|
|
||||||
{
|
|
||||||
// should fail (cannot override non-virtual method)
|
|
||||||
'override public foo': function() {},
|
|
||||||
} );
|
|
||||||
}
|
|
||||||
catch ( e )
|
|
||||||
{
|
|
||||||
assert.ok( e.message.search( 'foo' ),
|
|
||||||
"Non-virtual override error message should contain name of method"
|
|
||||||
);
|
|
||||||
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
assert.fail( "Should not be permitted to override non-virtual method" );
|
|
||||||
} )();
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* If we attempt to extend an object (rather than a constructor), we should
|
|
||||||
* simply use that as the prototype directly rather than attempting to
|
|
||||||
* instantiate it.
|
|
||||||
*/
|
|
||||||
( function testExtendingObjectWillNotAttemptInstantiation()
|
|
||||||
{
|
|
||||||
var obj = { foo: 'bar' };
|
|
||||||
|
|
||||||
assert.equal( obj.foo, Class.extend( obj, {} )().foo,
|
|
||||||
'Should be able to use object as prototype'
|
|
||||||
);
|
|
||||||
} )();
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* It only makes sense to extend from an object or function (constructor, more
|
|
||||||
* specifically)
|
|
||||||
*
|
|
||||||
* We could also test to ensure that the return value of the constructor is an
|
|
||||||
* object, but that is unnecessary for the time being.
|
|
||||||
*/
|
|
||||||
( function testWillThrowExceptionIfNonObjectOrCtorIsProvided()
|
|
||||||
{
|
|
||||||
assert['throws']( function()
|
|
||||||
{
|
|
||||||
Class.extend( 'foo', {} );
|
|
||||||
}, TypeError, 'Should not be able to extend from non-object or non-ctor' );
|
|
||||||
} )();
|
|
||||||
|
|
||||||
Loading…
Reference in New Issue