text: describe('class-instance-test.js', function() {
      describe('calling create', function() {
          it('should export the properties', function() {
              var MyClass = createClass({
                  x : 3
              });
  
              assert.equal(3, new MyClass().x);
          });
  
          it('should inherit the properties', function() {
              var Base = createClass({
                  x : 0,
                  y : 2
              });
  
              var Extend = createClass(Base, {
                  x : 1,
                  z : 3
              });
  
              var e = new Extend();
  
              assert.equal(1, e.x);
              assert.equal(2, e.y);
              assert.equal(3, e.z);
          });
  
          it('should not allow overwriting private properties.', function() {
              assert.throws(function() {
                  var Base = createClass({
                      _x : null
                  });
  
                  var Extend = createClass(Base, {
                      _x : null
                  });
              }, 'Private member _x is already defined');
          });
  
          it('should have the name exported correctly', function() {
              var CustomName = createClass("CustomName", {
                  // nothing
              });
  
              assert.ok(/function CustomName/.test(CustomName.toString()));
          });
  
          /**
           * This currently fails on V8, but it seems like a V8 issue.
           */
          it('stack trace checks should pass', function() {
              var CustomName = createClass("CustomName", {
                  checkMethodName : function() {
                      var stack = new Error("e").stack;
  
                      assert.ok(!/createClass\.checkMethodName/.test(stack),
                          "Wrong name for the class name inside calls:\n" +
                          stack +
                          "\n\nIf running inside a V8 JS engine, please ignore this test.");
                  }
              });
  
              var customName = new CustomName();
              customName.checkMethodName();
          });
  
          it('should have the class name on the `__name` property.', function() {
              var CustomClass = createClass("CustomClass", {
                  getClassName: function() {
                  	return this.__name;
                  }
              });
  
              var customClass = new CustomClass();
              assert.equal(customClass.getClassName(), "CustomClass");
          });
  
          it('should have the class `__name`, including when using inheritance', function() {
              var BaseClass = createClass("BaseClass", {
                  /**
                   * @return {string}
                   */
                  getClassName: function() {
                  	return this.__name;
                  }
              });
  
              var DerivedClass = createClass("DerivedClass", BaseClass, {
                  /**
                   * @return {string}
                   */
                  getDerivedName: function() {
                  	return this.__name;
                  }
              });
  
              var baseClass = new BaseClass();
              assert.equal(baseClass.getClassName(), "BaseClass");
  
              var derivedClass = new DerivedClass();
              assert.equal(derivedClass.getClassName(), "DerivedClass");
              assert.equal(derivedClass.getDerivedName(), "DerivedClass");
          });
      });
  });
  
  