[#25] Began moving test-class-visibility over to new test case style
Mike Gerwitz
parent
48dbfea990
commit
f15fa03a3b
|
|
@ -23,7 +23,6 @@
|
|||
*/
|
||||
|
||||
var common = require( './common' ),
|
||||
assert = require( 'assert' ),
|
||||
Class = common.require( 'class' ),
|
||||
Interface = common.require( 'interface' ),
|
||||
util = common.require( 'util' ),
|
||||
|
|
@ -136,63 +135,67 @@ var common = require( './common' ),
|
|||
;
|
||||
|
||||
|
||||
/**
|
||||
* Public members are the only members added to the instance's prototype to be
|
||||
* accessible externally
|
||||
*/
|
||||
( function testPublicMembersAreAccessbileExternally()
|
||||
require( 'common' ).testCase(
|
||||
{
|
||||
assert.equal(
|
||||
/**
|
||||
* Public members are the only members added to the instance's prototype to
|
||||
* be accessible externally
|
||||
*/
|
||||
'Public members are accessible externally': function()
|
||||
{
|
||||
this.assertEqual(
|
||||
foo.pub,
|
||||
pub,
|
||||
"Public properties are accessible via public interface"
|
||||
);
|
||||
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
foo.pubf(),
|
||||
pub,
|
||||
"Public methods are accessible via public interface"
|
||||
);
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* For reasons that are discussed in the next test (writing to public
|
||||
* properties), we need to make sure public members are available internally.
|
||||
* Actually, we don't need to test public methods, really, but it's in there for
|
||||
* good measure. Who knows what bugs may be introduced in the future.
|
||||
* properties), we need to make sure public members are available
|
||||
* internally. Actually, we don't need to test public methods, really, but
|
||||
* it's in there for good measure. Who knows what bugs may be introduced in
|
||||
* the future.
|
||||
*
|
||||
* This ensures that the getter is properly proxying the value to us.
|
||||
*/
|
||||
( function testPublicMembersAreAccessibleInternally()
|
||||
'Public members are accessible internally': function()
|
||||
{
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
foo.getProp( 'pub' ),
|
||||
pub,
|
||||
"Public properties are accessible internally"
|
||||
);
|
||||
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
foo.getProp( 'pubf' )(),
|
||||
pub,
|
||||
"Public methods are accessible internally"
|
||||
);
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* This may sound like an odd test, but it's actually very important. Due to how
|
||||
* private/protected members are implemented, it compromises public members. In
|
||||
* fact, public members would not work internally without what is essentially a
|
||||
* proxy via setters.
|
||||
* This may sound like an odd test, but it's actually very important. Due to
|
||||
* how private/protected members are implemented, it compromises public
|
||||
* members. In fact, public members would not work internally without what
|
||||
* is essentially a proxy via setters.
|
||||
*
|
||||
* This test is to ensure that the setter is properly forwarding writes to the
|
||||
* object within the prototype chain containing the public values. Otherwise,
|
||||
* setting the value would simply mask it in the prototype chain. The value
|
||||
* would appear to have changed internally, but when accessed externally, the
|
||||
* value would still be the same. That would obviously be a problem ;)
|
||||
* This test is to ensure that the setter is properly forwarding writes to
|
||||
* the object within the prototype chain containing the public values.
|
||||
* Otherwise, setting the value would simply mask it in the prototype chain.
|
||||
* The value would appear to have changed internally, but when accessed
|
||||
* externally, the value would still be the same. That would obviously be a
|
||||
* problem ;)
|
||||
*/
|
||||
( function testPublicPropertiesAreWritableInternally()
|
||||
'Public properties are writable internally': function()
|
||||
{
|
||||
var val = 'moomookittypoo';
|
||||
|
||||
|
|
@ -200,7 +203,7 @@ var common = require( './common' ),
|
|||
foo.setValue( 'pub', val );
|
||||
|
||||
// we should see that change internally...
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
foo.getProp( 'pub' ),
|
||||
val,
|
||||
"Setting the value of a public property internally should be " +
|
||||
|
|
@ -208,16 +211,16 @@ var common = require( './common' ),
|
|||
);
|
||||
|
||||
// ...as well as externally
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
foo.pub,
|
||||
val,
|
||||
"Setting the value of a public property internally should be " +
|
||||
"observable /externally/"
|
||||
);
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
( function testProtectedAndPrivateMembersAreNotAccessibleExternally()
|
||||
'Protected and private members are not accessible externally': function()
|
||||
{
|
||||
// browsers that do not support the property proxy will not support
|
||||
// encapsulating properties
|
||||
|
|
@ -226,38 +229,38 @@ var common = require( './common' ),
|
|||
return;
|
||||
}
|
||||
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
foo.peeps,
|
||||
undefined,
|
||||
"Protected properties are inaccessible via public interface"
|
||||
);
|
||||
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
foo.parts,
|
||||
undefined,
|
||||
"Private properties are inaccessible via public interface"
|
||||
);
|
||||
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
foo.protf,
|
||||
undefined,
|
||||
"Protected methods are inaccessible via public interface"
|
||||
);
|
||||
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
foo.privf,
|
||||
undefined,
|
||||
"Private methods are inaccessible via public interface"
|
||||
);
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* Protected members should be accessible from within class methods
|
||||
*/
|
||||
( function testProtectedMembersAreAccessibleInternally()
|
||||
'Protected members are accessible internally': function()
|
||||
{
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
foo.getProp( 'peeps' ),
|
||||
prot,
|
||||
"Protected properties are available internally"
|
||||
|
|
@ -265,20 +268,20 @@ var common = require( './common' ),
|
|||
|
||||
// invoke rather than checking for equality, because the method may be
|
||||
// wrapped
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
foo.getProp( 'protf' )(),
|
||||
prot,
|
||||
"Protected methods are available internally"
|
||||
);
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* Private members should be accessible from within class methods
|
||||
*/
|
||||
( function testPrivateMembersAreAccessibleInternally()
|
||||
'Private members are accessible internally': function()
|
||||
{
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
foo.getProp( 'parts' ),
|
||||
priv,
|
||||
"Private properties are available internally"
|
||||
|
|
@ -286,20 +289,20 @@ var common = require( './common' ),
|
|||
|
||||
// invoke rather than checking for equality, because the method may be
|
||||
// wrapped
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
foo.getProp( 'privf' )(),
|
||||
priv,
|
||||
"Private methods are available internally"
|
||||
);
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* Inheritance 101; protected members should be available to subtypes
|
||||
*/
|
||||
( function testProtectedMembersAreInheritedFromParent()
|
||||
'Protected members are inherited from parent': function()
|
||||
{
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
sub_foo.getProp( 'peeps' ),
|
||||
prot,
|
||||
"Protected properties are available to subtypes"
|
||||
|
|
@ -307,18 +310,19 @@ var common = require( './common' ),
|
|||
|
||||
// invoke rather than checking for equality, because the method may be
|
||||
// wrapped
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
sub_foo.getProp( 'protf' )(),
|
||||
prot,
|
||||
"Protected methods are available to subtypes"
|
||||
);
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* Interface 101-2: We do not want private members to be available to subtypes.
|
||||
* Interface 101-2: We do not want private members to be available to
|
||||
* subtypes.
|
||||
*/
|
||||
( function testPrivateMembersOfSupertypesAreInaccessibleToSubtypes()
|
||||
'Private members of supertypes are inaccessible to subtypes': function()
|
||||
{
|
||||
// browsers that do not support the property proxy will not support
|
||||
// encapsulating properties
|
||||
|
|
@ -327,7 +331,7 @@ var common = require( './common' ),
|
|||
return;
|
||||
}
|
||||
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
sub_foo.getProp( 'parts' ),
|
||||
undefined,
|
||||
"Private properties of supertypes should be unavailable to subtypes"
|
||||
|
|
@ -335,28 +339,28 @@ var common = require( './common' ),
|
|||
|
||||
// invoke rather than checking for equality, because the method may be
|
||||
// wrapped
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
sub_foo.getProp( 'privf' ),
|
||||
undefined,
|
||||
"Private methods of supertypes should be unavailable to subtypes"
|
||||
);
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* For good measure, let's make sure we didn't screw anything up. To ensure that
|
||||
* the same object isn't being passed around to subtypes, ensure that multiple
|
||||
* class instances do not share prototypes.
|
||||
* For good measure, let's make sure we didn't screw anything up. To ensure
|
||||
* that the same object isn't being passed around to subtypes, ensure that
|
||||
* multiple class instances do not share prototypes.
|
||||
*/
|
||||
( function testProtectedMembersAreNotSharedBetweenClassInstances()
|
||||
'Protected members are not shared between class instances': function()
|
||||
{
|
||||
var val = 'foobar';
|
||||
|
||||
foo.setValue( 'prot', val );
|
||||
|
||||
// ensure that class instances do not share values (ensuring the same object
|
||||
// isn't somehow being passed around)
|
||||
assert.notEqual(
|
||||
// ensure that class instances do not share values (ensuring the same
|
||||
// object isn't somehow being passed around)
|
||||
this.assertNotEqual(
|
||||
sub_foo.getProp( 'prot' ),
|
||||
val,
|
||||
"Class instances do not share protected values (subtype)"
|
||||
|
|
@ -366,119 +370,120 @@ var common = require( './common' ),
|
|||
var sub_foo2 = SubFoo();
|
||||
sub_foo2.setValue( 'prot', val );
|
||||
|
||||
assert.notEqual(
|
||||
this.assertNotEqual(
|
||||
sub_foo.getProp( 'prot' ),
|
||||
val,
|
||||
"Class instances do not share protected values (same type)"
|
||||
);
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* When a method is called, 'this' is bound to the property object containing
|
||||
* private and protected members. Returning 'this' would therefore be a very bad
|
||||
* thing. Not only would it break encapsulation, but it would likely have other
|
||||
* problems down the road.
|
||||
* When a method is called, 'this' is bound to the property object
|
||||
* containing private and protected members. Returning 'this' would
|
||||
* therefore be a very bad thing. Not only would it break encapsulation, but
|
||||
* it would likely have other problems down the road.
|
||||
*
|
||||
* Therefore, we have to check the return value of the method. If the return
|
||||
* value is the property object that it was bound to, we need to replace the
|
||||
* return value with the actual class instance. This allows us to transparently
|
||||
* enforce encapsulation. How sweet is that?
|
||||
* return value with the actual class instance. This allows us to
|
||||
* transparently enforce encapsulation. How sweet is that?
|
||||
*/
|
||||
( function testReturningSelfFromMethodShouldReturnInstanceNotPropObj()
|
||||
'Returning self from method should return instance not prop obj': function()
|
||||
{
|
||||
assert.deepEqual(
|
||||
this.assertDeepEqual(
|
||||
foo.getSelf(),
|
||||
foo,
|
||||
"Returning 'this' from a method should return instance of self"
|
||||
);
|
||||
|
||||
// what happens in the case of inheritance?
|
||||
assert.deepEqual(
|
||||
this.assertDeepEqual(
|
||||
sub_foo.getSelf(),
|
||||
sub_foo,
|
||||
"Returning 'this' from a super method should return the subtype"
|
||||
);
|
||||
|
||||
// finally, overridden methods should still return the instance
|
||||
assert.deepEqual(
|
||||
this.assertDeepEqual(
|
||||
sub_foo.getSelfOverride(),
|
||||
sub_foo,
|
||||
"Returning 'this' from a overridden method should return the subtype"
|
||||
"Returning 'this' from a overridden method should return subtype"
|
||||
);
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* This one's a particularly nasty bug that snuck up on me. Private members
|
||||
* should not be accessible to subtypes; that's a given. However, they need to
|
||||
* be accessible to the parent methods. For example, let's say class Foo
|
||||
* contains public method bar(), which invokes private method _baz(). This is
|
||||
* perfectly legal. Then SubFoo extends Foo, but does not override method bar().
|
||||
* Invoking method bar() should still be able to invoke private method _baz(),
|
||||
* because, from the perspective of the parent class, that operation is
|
||||
* perfectly legal.
|
||||
* should not be accessible to subtypes; that's a given. However, they need
|
||||
* to be accessible to the parent methods. For example, let's say class Foo
|
||||
* contains public method bar(), which invokes private method _baz(). This
|
||||
* is perfectly legal. Then SubFoo extends Foo, but does not override method
|
||||
* bar(). Invoking method bar() should still be able to invoke private
|
||||
* method _baz(), because, from the perspective of the parent class, that
|
||||
* operation is perfectly legal.
|
||||
*
|
||||
* The resolution of this bug required a slight system redesign. The short-term
|
||||
* fix was to declare any needed private members are protected, so that they
|
||||
* were accessible by the subtype.
|
||||
* The resolution of this bug required a slight system redesign. The
|
||||
* short-term fix was to declare any needed private members are protected,
|
||||
* so that they were accessible by the subtype.
|
||||
*/
|
||||
( function testParentMethodsCanAccessPrivateMembersOfParent()
|
||||
'Parent methods can access private members of parent': function()
|
||||
{
|
||||
// properties
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
sub_foo.getPrivProp(),
|
||||
priv,
|
||||
"Parent methods should have access to the private properties of the " +
|
||||
"parent"
|
||||
"Parent methods should have access to the private properties of " +
|
||||
"the parent"
|
||||
);
|
||||
|
||||
// methods
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
sub_foo.invokePriv(),
|
||||
priv,
|
||||
"Parent methods should have access to the private methods of the parent"
|
||||
"Parent methods should have access to the private methods of the " +
|
||||
"parent"
|
||||
);
|
||||
|
||||
// should apply to super-supertypes too
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
sub_sub_foo.getPrivProp(),
|
||||
priv,
|
||||
"Parent methods should have access to the private properties of the " +
|
||||
"parent (2)"
|
||||
"Parent methods should have access to the private properties of " +
|
||||
"the parent (2)"
|
||||
);
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
sub_sub_foo.invokePriv(),
|
||||
priv,
|
||||
"Parent methods should have access to the private methods of the " +
|
||||
"parent (2)"
|
||||
);
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* When a parent method is invoked, the parent should not be given access to the
|
||||
* private members of the invoking subtype. Why?
|
||||
* When a parent method is invoked, the parent should not be given access to
|
||||
* the private members of the invoking subtype. Why?
|
||||
*
|
||||
* This is not a matter of whether or not this is possible to do. In fact it's
|
||||
* relatively simple to implement. The issue is whether or not it makes sense.
|
||||
* Consider a compiled language. Let's say Foo and SubFoo (as defined in this
|
||||
* test case) were written in C++. Should Foo have access to a private property
|
||||
* on SubFoo when it is overridden?
|
||||
* This is not a matter of whether or not this is possible to do. In fact
|
||||
* it's relatively simple to implement. The issue is whether or not it makes
|
||||
* sense. Consider a compiled language. Let's say Foo and SubFoo (as
|
||||
* defined in this test case) were written in C++. Should Foo have access to
|
||||
* a private property on SubFoo when it is overridden?
|
||||
*
|
||||
* No - that doesn't make sense. The private member is not a member of Foo and
|
||||
* therefore Foo would fail to even compile. Alright, but we don't have such a
|
||||
* restriction in our case. So why not implement it?
|
||||
* No - that doesn't make sense. The private member is not a member of Foo
|
||||
* and therefore Foo would fail to even compile. Alright, but we don't have
|
||||
* such a restriction in our case. So why not implement it?
|
||||
*
|
||||
* Proponents of such an implementation are likely thinking of the act of
|
||||
* inheriting methods as a copy/paste type of scenario. If we inherit public
|
||||
* method baz(), and it were a copy/paste type of situation, then surely baz()
|
||||
* would have access to all of SubFoo's private members. But that is not the
|
||||
* case. Should baz() be defined as a member of Foo, then its scope is
|
||||
* restricted to Foo and its supertypes. That is not how OO works. It is /not/
|
||||
* copy/paste. It is inheriting functionality.
|
||||
* method baz(), and it were a copy/paste type of situation, then surely
|
||||
* baz() would have access to all of SubFoo's private members. But that is
|
||||
* not the case. Should baz() be defined as a member of Foo, then its scope
|
||||
* is restricted to Foo and its supertypes. That is not how OO works. It is
|
||||
* /not/ copy/paste. It is inheriting functionality.
|
||||
*/
|
||||
( function testParentsShouldNotHaveAccessToPrivateMembersOfSubtypes()
|
||||
'Parents should not have access to private members of subtypes': function()
|
||||
{
|
||||
// browsers that do not support the property proxy will not support
|
||||
// encapsulating properties
|
||||
|
|
@ -488,30 +493,30 @@ var common = require( './common' ),
|
|||
}
|
||||
|
||||
// property
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
sub_foo.nonOverrideGetProp( '_pfoo' ),
|
||||
undefined,
|
||||
"Parent should not have access to private properties of subtype when " +
|
||||
"a parent method is invoked"
|
||||
"Parent should not have access to private properties of subtype " +
|
||||
"whena parent method is invoked"
|
||||
);
|
||||
|
||||
// member
|
||||
assert.equal(
|
||||
this.assertEqual(
|
||||
sub_foo.nonOverrideGetProp( '_myOwnPrivateFoo' ),
|
||||
undefined,
|
||||
"Parent should not have access to private methods of subtype when " +
|
||||
"a parent method is invoked"
|
||||
"Parent should not have access to private methods of subtype " +
|
||||
"when a parent method is invoked"
|
||||
);
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* Visibility escalation (protected -> private) should be permitted
|
||||
*/
|
||||
( function testCanEscalateMemberVisibility()
|
||||
'Can escalate member visibility': function()
|
||||
{
|
||||
// escalate
|
||||
assert.doesNotThrow( function()
|
||||
this.assertDoesNotThrow( function()
|
||||
{
|
||||
Class(
|
||||
{
|
||||
|
|
@ -524,7 +529,7 @@ var common = require( './common' ),
|
|||
}, Error, "Can escalate visibility of subtype members" );
|
||||
|
||||
// same level of visibility
|
||||
assert.doesNotThrow( function()
|
||||
this.assertDoesNotThrow( function()
|
||||
{
|
||||
Class(
|
||||
{
|
||||
|
|
@ -535,17 +540,17 @@ var common = require( './common' ),
|
|||
'override protected baz': function() {},
|
||||
} );
|
||||
}, Error, "Can retain level of visibility for subtype members" );
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* We should /not/ be able to de-escalate member visibility
|
||||
* (public -> {protected,private}
|
||||
*/
|
||||
( function testCannotDeescalateMemberVisibility()
|
||||
'Cannot de-escalate member visibility': function()
|
||||
{
|
||||
// public -> protected
|
||||
assert.throws( function()
|
||||
this.assertThrows( function()
|
||||
{
|
||||
Class(
|
||||
{
|
||||
|
|
@ -553,9 +558,9 @@ var common = require( './common' ),
|
|||
} ).extend( {
|
||||
'protected foo': 'bar',
|
||||
} );
|
||||
}, Error, "Cannot de-escalate visibility of subtype props to protected" );
|
||||
}, Error, "Cannot de-escalate visibility of sub-props to protected" );
|
||||
|
||||
assert.throws( function()
|
||||
this.assertThrows( function()
|
||||
{
|
||||
Class(
|
||||
{
|
||||
|
|
@ -563,11 +568,11 @@ var common = require( './common' ),
|
|||
} ).extend( {
|
||||
'protected baz': function() {},
|
||||
} );
|
||||
}, Error, "Cannot de-escalate visibility of subtype methods to protected" );
|
||||
}, Error, "Cannot de-escalate visibility of sub-methods to protected" );
|
||||
|
||||
|
||||
// public -> private
|
||||
assert.throws( function()
|
||||
this.assertThrows( function()
|
||||
{
|
||||
Class(
|
||||
{
|
||||
|
|
@ -577,7 +582,7 @@ var common = require( './common' ),
|
|||
} );
|
||||
}, Error, "Cannot de-escalate visibility of subtype props to private" );
|
||||
|
||||
assert.throws( function()
|
||||
this.assertThrows( function()
|
||||
{
|
||||
Class(
|
||||
{
|
||||
|
|
@ -585,11 +590,11 @@ var common = require( './common' ),
|
|||
} ).extend( {
|
||||
'private baz': function() {},
|
||||
} );
|
||||
}, Error, "Cannot de-escalate visibility of subtype methods to private" );
|
||||
}, Error, "Cannot de-escalate visibility of sub-methods to private" );
|
||||
|
||||
|
||||
// protected -> private
|
||||
assert.throws( function()
|
||||
this.assertThrows( function()
|
||||
{
|
||||
Class(
|
||||
{
|
||||
|
|
@ -597,9 +602,9 @@ var common = require( './common' ),
|
|||
} ).extend( {
|
||||
'private foo': 'bar',
|
||||
} );
|
||||
}, Error, "Cannot de-escalate visibility of subtype props to private2" );
|
||||
}, Error, "Cannot de-escalate visibility of sub-props to private2" );
|
||||
|
||||
assert.throws( function()
|
||||
this.assertThrows( function()
|
||||
{
|
||||
Class(
|
||||
{
|
||||
|
|
@ -607,17 +612,17 @@ var common = require( './common' ),
|
|||
} ).extend( {
|
||||
'private baz': function() {},
|
||||
} );
|
||||
}, Error, "Cannot de-escalate visibility of subtype methods to private2" );
|
||||
} )();
|
||||
}, Error, "Cannot de-escalate visibility of sub-methods to private2" );
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* With the visibility implementation, it's possible that __super() will not
|
||||
* work properly with protected methods. This is because of the override lookup
|
||||
* process (which hopefully was fixed in the commit before this test was
|
||||
* originally introduced: ce736bea).
|
||||
* work properly with protected methods. This is because of the override
|
||||
* lookup process (which hopefully was fixed in the commit before this test
|
||||
* was originally introduced: ce736bea).
|
||||
*/
|
||||
( function testCallingSuperMethodWorksProperlyWithProtectedMethods()
|
||||
'Calling super method works properly with protected methods': function()
|
||||
{
|
||||
var val = 'foobar',
|
||||
result = Class( {
|
||||
|
|
@ -634,40 +639,43 @@ var common = require( './common' ),
|
|||
},
|
||||
} )().foo();
|
||||
|
||||
assert.equal( result, val,
|
||||
this.assertEqual( result, val,
|
||||
"__super() calls work with protected overrides"
|
||||
);
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* Concrete implementations of interfaces should have to follow the same
|
||||
* visibility de-escalation rules as defined in the above tests (otherwise, that
|
||||
* defeats the purpose of an interface). In other words, they must be public.
|
||||
* visibility de-escalation rules as defined in the above tests (otherwise,
|
||||
* that defeats the purpose of an interface). In other words, they must be
|
||||
* public.
|
||||
*/
|
||||
( function testVisibilityDeescalationRulesApplyToInterfaces()
|
||||
'Visibility de-escalation rulse apply to interfaces': function()
|
||||
{
|
||||
assert.throws( function()
|
||||
this.assertThrows( function()
|
||||
{
|
||||
Class.implement( Interface( { 'abstract public foo': [] } ) ).extend(
|
||||
Class.implement( Interface( { 'abstract public foo': [] } ) )
|
||||
.extend(
|
||||
{
|
||||
// should throw an exception; visibility de-escalation
|
||||
'protected foo': function() {},
|
||||
} );
|
||||
}
|
||||
);
|
||||
}, Error, "Cannot de-escalate visibility for interface members" );
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* Due to the way the property object is laid atop of the public members, we
|
||||
* need to ensure that protected methods' functionality can /actually/ be
|
||||
* overridden, since the protected method is higher in the prototype chain and
|
||||
* therefore will be accessed before the public method.
|
||||
* overridden, since the protected method is higher in the prototype chain
|
||||
* and therefore will be accessed before the public method.
|
||||
*
|
||||
* We don't care about private -> protected, because that's not possible through
|
||||
* inheritance.
|
||||
* We don't care about private -> protected, because that's not possible
|
||||
* through inheritance.
|
||||
*/
|
||||
( function testCanOverrideProtectedMethodFunctionalityWithPublic()
|
||||
'Can override protected method functionality with public': function()
|
||||
{
|
||||
// get the result of invoking overridden foo()
|
||||
var result = Class(
|
||||
|
|
@ -685,22 +693,22 @@ var common = require( './common' ),
|
|||
},
|
||||
} )().foo();
|
||||
|
||||
// if the override was successful, we'll be able to invoke the overridden
|
||||
// method
|
||||
assert.equal( result, true,
|
||||
// if the override was successful, we'll be able to invoke the
|
||||
// overridden method
|
||||
this.assertEqual( result, true,
|
||||
"Can properly override protected methods with public"
|
||||
);
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* There was an issue where the private property object was not proxying values
|
||||
* to the true protected values. This would mean that when the parent
|
||||
* There was an issue where the private property object was not proxying
|
||||
* values to the true protected values. This would mean that when the parent
|
||||
* initialized protected values, those values would be unavailable to the
|
||||
* subtype. Instead, the value available to the subtype was the value that was
|
||||
* assigned as the default value in the class definition.
|
||||
* subtype. Instead, the value available to the subtype was the value that
|
||||
* was assigned as the default value in the class definition.
|
||||
*/
|
||||
( function testProtectedValuesAreAvailableToSubtypesWhenSetByParentMethod()
|
||||
'Protected values are available to subtypes when set by parent': function()
|
||||
{
|
||||
var expected = 5,
|
||||
result = Class(
|
||||
|
|
@ -719,22 +727,22 @@ var common = require( './common' ),
|
|||
},
|
||||
} )().getVal();
|
||||
|
||||
assert.equal( result, expected,
|
||||
"Subtypes should have acess to protected properties values set by " +
|
||||
"super methods"
|
||||
this.assertEqual( result, expected,
|
||||
"Subtypes should have acess to protected properties values set " +
|
||||
"by super methods"
|
||||
);
|
||||
} )();
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* There was a bug introduced when we prevented protected members from
|
||||
* overriding public (since in the prototype chain, protected members are laid
|
||||
* atop public, and this cannot change). This bug would disallow protected
|
||||
* members from being overridden by other protected members.
|
||||
* overriding public (since in the prototype chain, protected members are
|
||||
* laid atop public, and this cannot change). This bug would disallow
|
||||
* protected members from being overridden by other protected members.
|
||||
*
|
||||
* This test is both a proof and a regression test.
|
||||
*/
|
||||
( function testCanProperlyOverrideProtectedWithProtected()
|
||||
'Can properly override protected with protected': function()
|
||||
{
|
||||
var val = 'foobar',
|
||||
result = Class(
|
||||
|
|
@ -757,9 +765,10 @@ var common = require( './common' ),
|
|||
|
||||
// if everything worked as expected, the value of 'val' will have been
|
||||
// returned and stored in 'result'
|
||||
assert.equal( result, val,
|
||||
"Protected methods can properly be overriden by another protected " +
|
||||
"method"
|
||||
this.assertEqual( result, val,
|
||||
"Protected methods can properly be overriden by another " +
|
||||
"protected method"
|
||||
);
|
||||
} )();
|
||||
},
|
||||
} );
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue