[#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

@@ -23,56 +23,60 @@
  */
 
 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,
+    wrappers             = common.require( '/MethodWrappers' ).standard
+;
 
-    builder = ClassBuilder(
+require( 'common' ).testCase(
-        common.require( '/MemberBuilder' )(
+{
+    setUp: function()
+    {
+        this.builder = ClassBuilder(
+            this.require( '/MemberBuilder' )(
                 MethodWrapperFactory( wrappers.wrapNew ),
                 MethodWrapperFactory( wrappers.wrapOverride )
             ),
-        common.require( '/VisibilityObjectFactoryFactory' ).fromEnvironment()
+            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.
      */
-( function testConstKeywordDeclaresPropertiesAsStatic()
+    'const keyword declares properties as static': function()
-{
+    {
         var val = 'baz',
-        Foo = builder.build(
+            Foo = this.builder.build(
             {
                 'const foo': val,
             } )
         ;
 
-    assert.equal( val, Foo.$('foo'),
+        this.assertEqual( val, Foo.$('foo'),
             "Const keyword should declare properties as static"
         );
-} )();
+    },
 
 
-/**
+    /**
      * As the name implies, constant properties should not be writable.
      */
-( function testConstKeywordCreatesImmutableProperty()
+    'const keyword creates immutable property': function()
-{
+    {
         try
         {
             // this should fail (trying to alter const prop foo)
-        builder.build( { 'const foo': 'bar'  } ).$( 'foo', 'baz' );
+            this.builder.build( { 'const foo': 'bar'  } ).$( 'foo', 'baz' );
         }
         catch ( e )
         {
-        assert.ok(
+            this.assertOk(
                 e.message.search( 'foo' ) !== -1,
                 "Const modification error should contain name of property"
             );
@@ -80,20 +84,20 @@ var common  = require( './common' ),
             return;
         }
 
-    assert.fail( "Constant properties should not be writable" );
+        this.fail( "Constant properties should not be writable" );
-} )();
+    },
 
 
-/**
+    /**
      * Unlike other languages such as PHP, the const keyword can have different
      * levels of visibility.
      */
-( function testVisibilityModifiersArePermittedWithConstKeyword()
+    'Access modifiers are permitted with const keyword': function()
-{
+    {
         var protval = 'bar',
             privval = 'baz',
 
-        Foo = builder.build(
+            Foo = this.builder.build(
             {
                 'protected const prot': protval,
                 'private   const priv': privval,
@@ -111,7 +115,7 @@ var common  = require( './common' ),
 
             // be sure to override each method to ensure we're checking references
             // on the subtype, *not* the parent type
-        SubFoo = builder.build( Foo,
+            SubFoo = this.builder.build( Foo,
             {
                 'public static getProt': function()
                 {
@@ -125,28 +129,29 @@ var common  = require( './common' ),
             } )
         ;
 
-    assert.equal( Foo.$('prot'), undefined,
+        this.assertEqual( Foo.$('prot'), undefined,
             "Protected constants are not available publicly"
         );
 
-    assert.equal( Foo.$('priv'), undefined,
+        this.assertEqual( Foo.$('priv'), undefined,
             "Private constants are not available publicly"
         );
 
-    assert.equal( Foo.getProt(), protval,
+        this.assertEqual( Foo.getProt(), protval,
             "Protected constants are available internally"
         );
 
-    assert.equal( Foo.getPriv(), privval,
+        this.assertEqual( Foo.getPriv(), privval,
             "Private constants are available internally"
         );
 
-    assert.equal( SubFoo.getProt(), protval,
+        this.assertEqual( SubFoo.getProt(), protval,
             "Protected constants are available to subtypes internally"
         );
 
-    assert.equal( SubFoo.getPriv(), undefined,
+        this.assertEqual( SubFoo.getPriv(), undefined,
             "Private constants are NOT available to subtypes internally"
         );
-} )();
+    },
+} );