Put class-implement tests into self-executing functions in testdox format to make them more easily recognized

- Eventually, I'd like for all the tests to be in this format

test/test-class-implement.js

@@ -30,79 +30,122 @@ var common    = require( './common' ),
 
 var Type = Interface.extend( {
         'abstract foo': [],
-});
+    }),
 
-var Type2 = Interface.extend( {
+    Type2 = Interface.extend( {
         'abstract foo2': [],
-});
+    }),
+
+    Foo       = {},
+    PlainFoo  = Class.extend(),
+    PlainFoo2 = {}
+;
 
 
-assert.ok(
+( function testClassExportsContainImplementMethodToExtendFromNoBaseClass()
+{
+    assert.ok(
         ( Class.implement instanceof Function ),
         "Class provides method to implement interfaces"
-);
+    );
+} )();
 
-var Foo       = {},
-    PlainFoo  = Class.extend(),
-    PlainFoo2 = {};
 
-assert.ok(
+( function testClassObjectsContainImplementMethodToImplementUsingItselfAsABase()
+{
+    assert.ok(
         ( PlainFoo.implement instanceof Function ),
         "Classes contain an implement() method"
-);
+    );
+} )();
 
-assert.doesNotThrow( function()
+
+( function testCanImplementInterfaceFromAnEmptyBase()
 {
+    assert.doesNotThrow( function()
+    {
         Foo = Class.implement( Type, Type2 );
-}, Error, "Class can implement interfaces" );
+    }, Error, "Class can implement interfaces" );
 
-assert.ok(
+    assert.ok(
         ( Class.isClass( Foo ) ),
         "Class returned from implementing interfaces on an empty base is a " +
             "valid class"
-);
+    );
+} )();
 
-assert.ok(
+
+( function testAbstractMethodsCopiedIntoNewClassUsingEmptyBase()
+{
+    assert.ok(
         ( ( Foo.prototype.foo instanceof Function )
             && ( Foo.prototype.foo2 instanceof Function )
         ),
         "Abstract methods are copied into the new class prototype (empty base)"
-);
+    );
+} )();
 
-assert.doesNotThrow( function()
+
+( function testCanImplementInterfaceAtopAnExistingClass()
 {
+    assert.doesNotThrow( function()
+    {
         PlainFoo2 = PlainFoo.implement( Type, Type2 );
-}, Error, "Concrete classes can implement interfaces" );
+    }, Error, "Classes can implement interfaces" );
 
-assert.ok(
+    assert.ok(
+        ( Class.isClass( PlainFoo2 ) ),
+        "Class returned from implementing interfaces on an existing base is a " +
+            "valid class"
+    );
+} )();
+
+
+( function testAbstractMethodsCopiedIntoNewClassUsingExistingBase()
+{
+    assert.ok(
         ( ( PlainFoo2.prototype.foo instanceof Function )
             && ( PlainFoo2.prototype.foo2 instanceof Function )
         ),
         "Abstract methods are copied into the new class prototype (concrete base)"
-);
+    );
+} )();
 
-assert.equal(
+
+( function testClassesImplementingInterfacesAreConsideredAbstractByDefault()
+{
+    assert.equal(
         ( Foo.isAbstract() && PlainFoo2.isAbstract() ),
         true,
         "Classes that implements interface(s) are considered abstract if the " +
             "implemented methods have no concrete implementations"
-);
+    );
+} ) ();
 
-assert.equal(
+
+( function testAbstractMethodListUpdatedWhenInterfaceImplemented()
+{
+    // no base
+    assert.equal(
         Foo.abstractMethods.length,
         2,
         "Abstract methods list is updated when interface is implemented " +
             "(empty base)"
-);
+    );
 
-assert.equal(
+    // PlainFoo base
+    assert.equal(
         PlainFoo2.abstractMethods.length,
         2,
         "Abstract methods list is updated when interface is implemented " +
             "(concrete base)"
-);
+    );
+} )();
 
-assert.ok(
+
+( function testProperAbstractMethodsAreCopiedFromInterface()
+{
+    assert.ok(
         ( ( Foo.abstractMethods[ 0 ] == 'foo' )
             && ( Foo.abstractMethods[ 1 ] == 'foo2' )
         )
@@ -110,11 +153,14 @@ assert.ok(
             && ( PlainFoo2.abstractMethods[ 1 ] == 'foo2' )
         ),
         "Abstract methods list contains names of implemented methods"
-);
+    );
+} )();
 
 
-// concrete implementation so that we can instantiate it
+( function testInstancesOfClassesAreInstancesOfTheirImplementedInterfaces()
-var ConcreteFoo = Foo.extend(
+{
+    // concrete implementation so that we can instantiate it
+    var ConcreteFoo = Foo.extend(
         {
             foo:  function() {},
             foo2: function() {},
@@ -122,11 +168,12 @@ var ConcreteFoo = Foo.extend(
 
         concrete_inst = new ConcreteFoo();
 
-assert.ok(
+    assert.ok(
         ( concrete_inst.isInstanceOf( Type )
             && concrete_inst.isInstanceOf( Type2 )
         ),
         "Instances of classes implementing interfaces are considered to be " +
             "instances of the implemented interfaces"
-);
+    );
+} )();