From 110d937838aa861c76bb1241db77d80d7eb1c11e Mon Sep 17 00:00:00 2001 From: Mike Gerwitz Date: Wed, 2 Nov 2011 19:11:12 -0400 Subject: [PATCH] [#25] Began converting test-class_builder-const to test case - Not yet renaming, as the conversion is not yet complete --- test/test-class_builder-const.js | 219 ++++++++++++++++--------------- 1 file changed, 112 insertions(+), 107 deletions(-) diff --git a/test/test-class_builder-const.js b/test/test-class_builder-const.js index 306ca41..af2b217 100644 --- a/test/test-class_builder-const.js +++ b/test/test-class_builder-const.js @@ -23,130 +23,135 @@ */ var common = require( './common' ), - assert = require( 'assert' ), // XXX: get rid of this disgusting mess; we're mid-refactor and all these // dependencies should not be necessary for testing ClassBuilder = common.require( '/ClassBuilder' ), MethodWrapperFactory = common.require( '/MethodWrapperFactory' ), - wrappers = common.require( '/MethodWrappers' ).standard, - - builder = ClassBuilder( - common.require( '/MemberBuilder' )( - MethodWrapperFactory( wrappers.wrapNew ), - MethodWrapperFactory( wrappers.wrapOverride ) - ), - common.require( '/VisibilityObjectFactoryFactory' ).fromEnvironment() - ) + wrappers = common.require( '/MethodWrappers' ).standard ; - -/** - * The const keyword should result in a static property. The rationale for this - * is that, if a value is constant, then instances do not make sense. - */ -( function testConstKeywordDeclaresPropertiesAsStatic() +require( 'common' ).testCase( { - var val = 'baz', - Foo = builder.build( + setUp: function() + { + this.builder = ClassBuilder( + this.require( '/MemberBuilder' )( + MethodWrapperFactory( wrappers.wrapNew ), + MethodWrapperFactory( wrappers.wrapOverride ) + ), + this.require( '/VisibilityObjectFactoryFactory' ).fromEnvironment() + ) + }, + + + /** + * The const keyword should result in a static property. The rationale for this + * is that, if a value is constant, then instances do not make sense. + */ + 'const keyword declares properties as static': function() + { + var val = 'baz', + Foo = this.builder.build( + { + 'const foo': val, + } ) + ; + + this.assertEqual( val, Foo.$('foo'), + "Const keyword should declare properties as static" + ); + }, + + + /** + * As the name implies, constant properties should not be writable. + */ + 'const keyword creates immutable property': function() + { + try { - 'const foo': val, - } ) - ; + // this should fail (trying to alter const prop foo) + this.builder.build( { 'const foo': 'bar' } ).$( 'foo', 'baz' ); + } + catch ( e ) + { + this.assertOk( + e.message.search( 'foo' ) !== -1, + "Const modification error should contain name of property" + ); - assert.equal( val, Foo.$('foo'), - "Const keyword should declare properties as static" - ); -} )(); + return; + } + + this.fail( "Constant properties should not be writable" ); + }, -/** - * As the name implies, constant properties should not be writable. - */ -( function testConstKeywordCreatesImmutableProperty() -{ - try + /** + * Unlike other languages such as PHP, the const keyword can have different + * levels of visibility. + */ + 'Access modifiers are permitted with const keyword': function() { - // this should fail (trying to alter const prop foo) - builder.build( { 'const foo': 'bar' } ).$( 'foo', 'baz' ); - } - catch ( e ) - { - assert.ok( - e.message.search( 'foo' ) !== -1, - "Const modification error should contain name of property" + var protval = 'bar', + privval = 'baz', + + Foo = this.builder.build( + { + 'protected const prot': protval, + 'private const priv': privval, + + 'public static getProt': function() + { + return this.$('prot'); + }, + + 'public static getPriv': function() + { + return this.$('priv'); + }, + } ), + + // be sure to override each method to ensure we're checking references + // on the subtype, *not* the parent type + SubFoo = this.builder.build( Foo, + { + 'public static getProt': function() + { + return this.$('prot'); + }, + + 'public static getPriv': function() + { + return this.$('priv'); + }, + } ) + ; + + this.assertEqual( Foo.$('prot'), undefined, + "Protected constants are not available publicly" ); - return; - } + this.assertEqual( Foo.$('priv'), undefined, + "Private constants are not available publicly" + ); - assert.fail( "Constant properties should not be writable" ); -} )(); + this.assertEqual( Foo.getProt(), protval, + "Protected constants are available internally" + ); + this.assertEqual( Foo.getPriv(), privval, + "Private constants are available internally" + ); -/** - * Unlike other languages such as PHP, the const keyword can have different - * levels of visibility. - */ -( function testVisibilityModifiersArePermittedWithConstKeyword() -{ - var protval = 'bar', - privval = 'baz', + this.assertEqual( SubFoo.getProt(), protval, + "Protected constants are available to subtypes internally" + ); - Foo = builder.build( - { - 'protected const prot': protval, - 'private const priv': privval, - - 'public static getProt': function() - { - return this.$('prot'); - }, - - 'public static getPriv': function() - { - return this.$('priv'); - }, - } ), - - // be sure to override each method to ensure we're checking references - // on the subtype, *not* the parent type - SubFoo = builder.build( Foo, - { - 'public static getProt': function() - { - return this.$('prot'); - }, - - 'public static getPriv': function() - { - return this.$('priv'); - }, - } ) - ; - - assert.equal( Foo.$('prot'), undefined, - "Protected constants are not available publicly" - ); - - assert.equal( Foo.$('priv'), undefined, - "Private constants are not available publicly" - ); - - assert.equal( Foo.getProt(), protval, - "Protected constants are available internally" - ); - - assert.equal( Foo.getPriv(), privval, - "Private constants are available internally" - ); - - assert.equal( SubFoo.getProt(), protval, - "Protected constants are available to subtypes internally" - ); - - assert.equal( SubFoo.getPriv(), undefined, - "Private constants are NOT available to subtypes internally" - ); -} )(); + this.assertEqual( SubFoo.getPriv(), undefined, + "Private constants are NOT available to subtypes internally" + ); + }, +} );