test/test.html

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html>
<head>
    <meta http-equiv="Content-type" content="text/html; charset=utf-8">
    <title>JS.Class tests</title>
    <script src="prototype.js" type="text/javascript" charset="utf-8"></script>
    <script src="unittest.js" type="text/javascript" charset="utf-8"></script>
    <script src="globals.js" type="text/javascript"></script>
    <script type="text/javascript" charset="utf-8">
      timeA = Number(new Date);
    </script>
    <script src="../build/min/class.js" type="text/javascript" charset="utf-8"></script>
    <script src="../build/min/patterns.js" type="text/javascript" charset="utf-8"></script>
    <script type="text/javascript" charset="utf-8">
      timeB = Number(new Date);
      window.console && console.log((timeB - timeA) / 1000);
    </script>
    <link rel="stylesheet" href="test.css" type="text/css" media="screen" title="no title" charset="utf-8">
    <script type="text/javascript" charset="utf-8">
    
    JS.Packages(function() { with(this) {
    
        var cdn  = 'http://yui.yahooapis.com/';
        var yui  = cdn + '2.5.2/build/';
        
        pkg('YAHOO',                    yui + 'yahoo-dom-event/yahoo-dom-event.js');
        pkg('YAHOO.lang',               yui + 'yahoo-dom-event/yahoo-dom-event.js');
        pkg('YAHOO.util.Dom',           yui + 'yahoo-dom-event/yahoo-dom-event.js');
        pkg('YAHOO.util.Event',         yui + 'yahoo-dom-event/yahoo-dom-event.js');
        
        pkg('YAHOO.util.Selector',      yui + 'selector/selector-beta-min.js');
        
        pkg('YAHOO.util.Connection',    yui + 'connection/connection-min.js');
        pkg('YAHOO.util.Get',           yui + 'get/get-min.js');
        
        pkg('YAHOO.util.Anim',          yui + 'animation/animation-min.js');
        pkg('YAHOO.util.ColorAnim',     yui + 'animation/animation-min.js');
        
        pkg('YAHOO.util.History',       yui + 'history/history-min.js');
        
        pkg('YAHOO.util.Anim')
            .requires('YAHOO')
            .requires('YAHOO.util.Event');
        
        pkg('YAHOO.util.Selector')
            .requires('YAHOO')
            .requires('YAHOO.util.Anim')
            .requires('YAHOO.util.Connection');
    }});
    
    alert(window.YAHOO ? 'YUI version ' + YAHOO.VERSION : 'YAHOO not defined');
    require('YAHOO.util.Selector', function() {
        setTimeout(function() {
            alert('Using YAHOO.util.Selector: ' + YAHOO.util.Selector.query('td').length);
        }, 2000);
    });
    
    //================================================================
    // Test that method inheritance works as it does in Ruby.
    // See module.rb for equivalent Ruby code
    //================================================================
    
    var ModA = new JS.Module({
        include: {/** JS.StackTrace **/},
        speak: function() {
            return "speak() in ModA";
        },
        extend: {
            included: function(mod) {
                this.incs = this.incs || [];
                this.incs.push(mod);
            },
            
            extended: function(mod) {
                this.exts = this.exts || [];
                this.exts.push(mod);
            }
        }
    });
    
    var ModB = new JS.Module({
        speak: function() {
            return "speak() in ModB, " + this.callSuper();
        }
    });
    
    var ModC = new JS.Module();
    ModC.include({
        include: [ModA, {/** JS.StackTrace **/}],
        speak: function() {
            return this.callSuper() + ", and in ModC";
        }
    });
    ModC.include(ModB);
    ModC.included = ModA.included;
    
    var ModD = new JS.Module({
        include: ModA,
        speak: function() {
            return "speak() in ModD, " + this.callSuper();
        }
    });
    
    var InheritanceTester = new JS.Class({
        include: [ModD, ModC, {/** JS.StackTrace **/}],
        
        initialize: function() { this.speak() },
        
        speak: function() {
            return this.callSuper() + ", and in class Foo";
        },
        
        extend: {
            children: [],
            inherited: function(klass) {
                this.children.push(klass);
            }
        }
    });
    
    var SingletonMethodTester = new JS.Class({
        speak: function() {
            return "speak() in class Bar";
        }
    });
    
    var SpecialClass = new JS.Class(JS.Class, {
        make: function(name, func) {
            return [name, this.callSuper()];
        }
    });
    
    var Special = new SpecialClass({});
    
    var SpecialSub = new SpecialClass(InheritanceTester, {
        speak: function() {
            return this.callSuper().toUpperCase();
        }
    });
    
    var HookTester = new JS.Class(InheritanceTester);
    
    JS.extend(Object, {
        children: [],
        inherited: function(klass) {
            this.children.push(klass);
        }
    });
    
    var Foo = new JS.Class({
        talk: function() {
            return 'talk';
        }
    });
    
    var Bar = new JS.Class(Foo, {
        talk: function() {
            return this.callSuper() + this.callSuper();
        }
    });
    
    ExtendingModule = new JS.Module({
        someMethod: function() {
            return 'I am working'
        },
        extend: {
            included: function(base) {
                base.extend(this);
            }
        }
    });     
    
    //================================================================
    //================================================================
    
    var Animal = new JS.Class({
        extend: {
            find: function(thing) { return 'Animal finds ' + thing; },
            create: function(thing) { return this.find(thing) + ' and Animal creates ' + thing; }
        },
        initialize: function(name) {
            this.name = String(name);
        },
        speak: function(stuff) {
            return 'My name is ' + this.name + ' and I like ' + stuff;
        }
    });

    var Bear = new JS.Class(Animal, {
        extend: {
            create: function(thing) {
                return this.callSuper(thing) + ', but Bear creates other stuff'
            }
        },
        speak: function(stuff) {
            return this.callSuper(stuff).toUpperCase();
        }
    });

    var NoSuperBear = new JS.Class(Bear, {
        speak: function() { return this.name.toUpperCase(); }
    });

    var Koala = new JS.Class(Bear, {
        speak: function(stuff) {
            return "I'm not really a Bear, but I do like " + stuff;
        }
    });

    var Dog = new JS.Class(Animal, {
        bark: function() { return this.name + ' says WOOF!'; }
    });

    Dog.Interface = new JS.Interface(['speak', 'bark']);

    var Pitbull = new JS.Class(Dog, {
        extend: {
            canBiteYourLegsOff: function() {
                return this.biting;
            },
            biting: 'Of course it can'
        },
        speak: function() {
            return this.callSuper();
        }
    });

    var Camel = new JS.Singleton(Animal, {
        fillHumpsWithWater: function() {}
    });

    //================================================================
    // Let's implement the classes from here: http://www.ajaxpath.com/javascript-inheritance
    // and make sure Crockford's problems aren't encountered.
    //================================================================
    
    var BaseClass = new JS.Class({
        getName: function() { return 'BaseClass(' + this.getId() + ')'; },
        getId: function() { return 1; }
    });

    var SubClass = new JS.Class(BaseClass, {
        getName: function() {
            return 'SubClass(' + this.getId() + ') extends ' + this.callSuper();
        },
        getId: function() { return 2; }
    });

    var TopClass = new JS.Class(SubClass, {
        getName: function() {
            return 'TopClass(' + this.getId() + ') extends ' + this.callSuper();
        },
        getId: function() {
            return this.callSuper();
        }
    });

    //================================================================
    //================================================================

    var NativeClass = function() {};
    NativeClass.prototype = {
        getName: function() { return 'Native'; }
    };

    var ChildOfNativeClass = new JS.Class(NativeClass, {
        getName: function() {
            return this.callSuper();
        }
    });
    
    //================================================================
    //================================================================

    var Paginator = new JS.Class({
        initialize: function(n) {
            this.count = n;
            this.createItems(n);
        },
        createItems: function(n) {
            this.items = this.items || [];
            for (var i = 0; i < n; i++)
                this.items.push(new this.klass.Item(i));
        }
    });
    
    Paginator.extend({Item: new JS.Class({
        initialize: function(n) {
            this.name = 'Item';
            this.number = n;
        },
        getName: function() {
            return this.name + ' ' + this.getNumber();
        },
        getNumber: function() {
            return this.number;
        }
    }) });
    
    var Gallery = new JS.Class(Paginator, {
        createItems: function(n) { this.callSuper(4 * n); }
    });
    
    var ItemInheritor = new JS.Class(Gallery);
    ItemInheritor.Item = new JS.Class(Gallery.Item, {
        getNumber: function() { return this.callSuper() + 7; }
    });
    
    //================================================================
    //================================================================

    var Enum = new JS.Module({
        each: function() {},
        some: function() {},
        
        extend: {
            included: function() {
                this.hasBeenIncluded = this.hasBeenIncluded || 0;
                this.hasBeenIncluded++;
            }
        }
    });
    
    var ActiveRecord = new JS.Module({
        include: Enum,
        
        save: function() {},
        validate: function() {},
        attributes: function() {},
        
        extend: {
            included: function(base) {
                base.extend({
                    find: function() {},
                    create: function() {}
                });
            }
        }
    });
    
    var BlankClass = new JS.Class();
    BlankClass.include(ActiveRecord);
    
    //================================================================
    //================================================================

    // A 'comparable' class whose instances can be compared and sorted
    var TodoItem = new JS.Class({
        include: JS.Comparable,
        
        initialize: function(position, task) {
            this.position = position;
            this.task = task || "";
        },
        
        compareTo: function(other) {
            if (this.position < other.position)
                return -1;
            else if (this.position > other.position)
                return 1;
            else
                return 0;
        }
    });
    
    var Collection = new JS.Class({
        include: JS.Enumerable,
        initialize: function() {
          this.length = arguments.length;
          this._list = [];
          for (var i = 0, n = this.length; i < n; i++)
            this._list.push(arguments[i]);
        },
        forEach: function(block, context) {
          for (var i = 0, n = this._list.length; i < n; i++)
            block.call(context || null, this._list[i], i);
        }
    });
    
    var PairedHash = new JS.Class({
        include: JS.Enumerable,
        initialize: function(object) {
            this._object = object || {};
        },
        forEach: function(block, context) {
            for (var key in this._object)
                block.call(context || null, {key: key, value: this._object[key]});
        }
    });
    
    var KeyValueHash = new JS.Class({
        include: JS.Enumerable,
        initialize: function(object) {
            this._object = object || {};
        },
        forEach: function(block, context) {
            for (var key in this._object)
                block.call(context || null, key, this._object[key]);
        },
        keys: function() {
            return this.map(function(key, value) { return key; });
        },
        values: function() {
            return this.collect(function(key, value) { return value; });
        }
    });
    
    //================================================================
    //================================================================

    var Publisher = new JS.Class({
        include: JS.Observable
    });
    
    //================================================================
    //================================================================

    var Bicycle = new JS.Class({
        initialize: function(model, gears) {
            this.model = model;
            this.gears = gears;
        },
        getModel: function() {
            return this.model;
        },
        getPrice: function() {
            return 10 * this.gears;
        }
    });
    
    var HeadlightDecorator = new JS.Decorator(Bicycle, {
        getPrice: function() {
            return 5 + this.component.getPrice();
        }
    });
    
    var PedalsDecorator = new JS.Decorator(Bicycle, {
        getPrice: function() {
            return 24 + this.component.getPrice();
        },
        rotatePedals: function() {
            return 'Turning the pedals';
        }
    });
    
    //================================================================
    //================================================================

    var Fiddler = new JS.Class({
        include: JS.State,
        
        initialize: function() {
            this.count = 0;
            this.setState('optimism');
        },
        
        getCount: function() { return this.count; },
        
        states: {
            optimism: {
                stepForward: function() {
                    this.count += 2;
                },
                laughOutLoud: function() {
                    return 'Ha-ha!'
                }
            },
            pessimism: {
                stepForward: function() {
                    this.count -= 1;
                }
            }
        }
    });
    
    var DecoratedFiddler = new JS.Decorator(Fiddler, {
        stepForward: function() {
            this.component.stepForward();
            this.component.count += 100;
        },
        laughOutLoud: function() {
            var result = this.component.laughOutLoud();
            return (typeof result == 'string') ? result.toUpperCase() : 'WRONG';
        },
        count: function() {
            return this.component.count;
        }
    });
    
    var ProxiedFiddler = new JS.Proxy.Virtual(Fiddler);
    
    var InheritableStateMachine = new JS.Class({
        include: JS.State,
        
        initialize: function() {
            this.setState('doggies');
            this.name = 'Alice';
        },
        
        states: {
            ponies: {
                speak: function() { return this.name + ' likes ponies!' }
            },
            doggies: {
                speak: function() { return 'doggies!' }
            }
        }
    });
    
    var ChildStateMachine = new JS.Class(InheritableStateMachine, {
        states: {
            doggies: {
                speak: function() {
                    return this.callSuper() + " aren't they cute?";
                }
            },
            
            poundingTechnoMusic: {
                speak: function() {
                    return 'Do you know where your children are?';
                }
            }
        }
    });
    
    var AnotherChildStateMachine = new JS.Class(ChildStateMachine, {
        initialize: function() {
            this.name = 'Jenny';
        },
        states: {
            ponies: {
                speak: function() {
                    return this.callSuper() + " aren't they cute?";
                }
            }
        }
    });
    
    //================================================================
    //================================================================

    var Forwarder = new JS.Class({
        extend: JS.Forwardable,
        initialize: function() {
            this.fiddler = new Fiddler;
        }
    });
    Forwarder.defineDelegators('fiddler', 'setState', 'stepForward');
    Forwarder.defineDelegator('fiddler', 'getCount', 'count');
    
    //================================================================
    //================================================================

    var Rails = new JS.Class();
    var RailsModule = new JS.Module({
        setValue: function(value) {
            this.numericValue = value;
        }
    });
    
    JS.Ruby(Rails, function() { with(this) {
        
        include(JS.Observable);
        extend(JS.Forwardable);
        
        // test DSL extension
        extend(RailsModule);
        with (self) {
            alias('myValueIs', 'setValue');
        }
        myValueIs(27);
        
        def('initialize', function() {
            this.attributes = {};
        });
        
        def('updateAttributes', function(attrs) {
            for (var key in attrs)
                this.attributes[key] = attrs[key];
            this.notifyObservers(this);
        });
        
        defineDelegator('attributes', 'name', 'getName');
        alias('itsName', 'getName');
        
        with (self) {
            def('create', function(attrs) {
                var rails = new this;
                rails.updateAttributes(attrs || {});
                return rails;
            });
            
            alias('make', 'create');
        }
        
        var r = make({name: 'Rails instance'});
        window.console && console.log(instanceMethod('updateAttributes').toString());
        window.console && console.log(r.itsName());
    }});
    
    window.console && console.log(Rails.numericValue);
    
    </script>
    <script type="text/javascript" charset="utf-8">
      timeB = Number(new Date);
      window.console && console.log((timeB - timeA) / 1000);
    </script>
    
</head>
<body>
    
    <div id="testlog"></div>
    
    <script type="text/javascript" charset="utf-8">
        
    new Test.Unit.Runner({
        /*
        testStaticTyping: function() { with(this) {
            var foo = function(animal) {
                return 'something';
            };
            
            var pitbull = new Pitbull('Grrr');
            
            benchmark(function() { foo(pitbull, pitbull, pitbull, 'foo') }, 3000);
            
            foo = foo.expects(Animal, Pitbull, Dog, 'string', Array)
                    .returns('string');
            
            benchmark(function() { foo(pitbull, pitbull, pitbull, 'foo', []) }, 3000);
        }},
        */
        
        testRubyishInheritance: function() { with(this) {
            var tester = new InheritanceTester();
            assertEqual("speak() in ModB, speak() in ModD, speak() in ModA, and in ModC, and in class Foo", tester.speak());
            
            tester = new SingletonMethodTester();
            assertEqual('speak() in class Bar', tester.speak());
            tester.extend({speak: function() {
                return this.callSuper().toUpperCase()
            } });
            assertEqual('SPEAK() IN CLASS BAR', tester.speak());
            tester.extend(ModB);
            assertEqual('SPEAK() IN MODB, SPEAK() IN CLASS BAR', tester.speak());
        }},
        
        testAncestors: function() { with(this) {
            assertEnumEqual([JS.ObjectMethods, ModA, ModD, ModB, ModC, InheritanceTester], InheritanceTester.ancestors());
        }},
        
        testCoreClasses: function() { with(this) {
            assertEqual(JS.Class, JS.Module.klass);
            assertEqual(JS.Class, JS.Class.klass);
            assertEqual(1, JS.Module.subclasses.length);
            assertEqual(JS.Class, JS.Module.subclasses[0]);
            assertEqual(Object, JS.Module.superclass);
            assertEqual(1, JS.Class.subclasses.length);
            assertEqual(SpecialClass, JS.Class.subclasses[0]);
            assertEqual(JS.Module, JS.Class.superclass);
        }},
        
        testInheritanceFromClass: function() { with(this) {
            assertEqual(JS.Class, SpecialClass.klass);
            assertEqual(JS.Class, SpecialClass.superclass);
            assertEqual(SpecialClass, Special.klass);
            assertEqual(InheritanceTester, SpecialSub.superclass)
            var things = Special.make('something', function() { return 'else' });
            assertEqual('something', things[0]);
            assertEqual('else', things[1]());
            assertEqual("speak() in ModB, speak() in ModD, speak() in ModA, and in ModC, and in class Foo".toUpperCase(), new SpecialSub().speak());
        }},
        
        testIsA: function() { with(this) {
            var obj = new InheritanceTester();
            assert(obj.isA(InheritanceTester));
            assert(obj.isA(ModA));
            assert(obj.isA(ModB));
            assert(obj.isA(ModC));
            assert(obj.isA(JS.ObjectMethods));
            assert(obj.isA(Object));
            
            obj = new SpecialSub();
            assert(obj.isA(SpecialSub));
            assert(obj.isA(InheritanceTester));
            assert(obj.isA(ModA));
            assert(obj.isA(ModB));
            assert(obj.isA(ModC));
            assert(obj.isA(JS.ObjectMethods));
            assert(obj.isA(Object));
            
            assert(!obj.isA(JS.Class));
            assert(!obj.isA(JS.Module));
            
            var SomeClass = new JS.Class({ initialize: function(){} });
            assert(InheritanceTester.isA(JS.Class));
            assert(InheritanceTester.isA(JS.Module));
            assert(Special.isA(JS.Class));
            assert(Special.isA(SpecialClass));
            assert(Special.isA(JS.Module));
            assert(!(new SomeClass).isA(InheritanceTester));
            
            assert(JS.Module.isA(JS.Module));
            assert(JS.Module.isA(JS.Class));
            assert(JS.Class.isA(JS.Module));
            assert(JS.Class.isA(JS.Class));
        }},
        
        testExtend: function() { with(this) {
            var obj = new InheritanceTester();
            var i = 0;
            for (var key in obj) { if (obj.hasOwnProperty(key)) i++; }
            assertEqual(0, i);
            obj.extend({
                speak: function() {
                    return this.callSuper().replace(/[aeiou]/ig, '_');
                }
            });
            var keys = [];
            for (var key in obj) { if (obj.hasOwnProperty(key)) keys.push(key); }
            assertEqual(2, keys.length);
            keys.sort();
            assertEqual('__meta__', keys[0]);
            assertEqual('speak', keys[1]);
            assertEqual("sp__k() _n M_dB, sp__k() _n M_dD, sp__k() _n M_d_, _nd _n M_dC, _nd _n cl_ss F__", obj.speak());
        }},
        
        testTypeDetectionOnExtendedObjects: function() { with(this) {
            var mod = new JS.Module({
                jabba: function() { return 'It says JABBA!' }
            });
            var klass = new JS.Class();
            assert(!klass.isA(mod));
            klass.extend(mod);
            assert(klass.isA(mod));
            assertEqual('It says JABBA!', klass.jabba());
            var obj = new klass;
            assertEqual(undefined, obj.jabba);
            assert(!obj.isA(mod));
            assert(obj.isA(klass));
            obj.extend(mod);
            assert(obj.isA(mod));
            assertEqual('It says JABBA!', obj.jabba());
        }},
        
        testHooks: function() { with(this) {
            assertEqual(2, ModA.incs.length);
            assertEqual(ModC, ModA.incs[0]);
            var obj = new JS.Interface(['foo']);
            obj.extend(ModA);
            assertEqual(1, ModA.exts.length);
            assertEqual(obj, ModA.exts[0]);
            assertEqual(1, ModC.incs.length);
            assertEqual(InheritanceTester, ModC.incs[0]);
            var klass = new JS.Class();
            klass.extend(ModA);
            assertEqual('speak() in ModA', klass.speak());
            assertEqual(2, ModA.exts.length);
            assertEqual(klass, ModA.exts[1]);
        }},
        
        testIncludeCausingExtend: function() { with(this) {
            var klass = new JS.Class({include: ExtendingModule});
            
            assertEqual('I am working', klass.someMethod());
            assertEqual('I am working', (new klass).someMethod());
        }},
        
        testClassDefinition: function() { with(this) {
            var frog = new Animal('Kermit');
            assertEqual('My name is Kermit and I like Ms. Piggy', frog.speak('Ms. Piggy'));
            assertEqual('Animal finds food', Animal.find('food'));
            assertEqual('Animal finds shelter and Animal creates shelter', Animal.create('shelter'));
        }},
        
        testEmptyClass: function() { with(this) {
            var klass = new JS.Class();
            var instance = new klass;
            assert(instance.isA(klass));
        }},
        
        testInheritance: function() { with(this) {
            var yogi = new Bear('Yogi');
            assertEqual('MY NAME IS YOGI AND I LIKE PICNICS', yogi.speak('picnics'));
            assertEqual('Animal finds honey', Bear.find('honey'));
            assertEqual('Animal finds nothing and Animal creates nothing, but Bear creates other stuff', Bear.create('nothing'));
        }},
        
        // http://blog.jcoglan.com/2007/11/14/wheres-my-inheritance/
        testLateBinding: function() { with(this) {
            var Car = new JS.Class({});
            var Ford = new JS.Class(Car);
            var ModelT = new JS.Class(Ford);
            
            Car.include({drive: function() {
                return 'Driving my Car';
            }});
            
            ModelT.include({drive: function() {
                return this.callSuper() + ', a Model T';
            }});
            
            assertEqual('Driving my Car, a Model T', new ModelT().drive());
            
            Ford.include({drive: function() {
                return 'Driving my Ford';
            }});
            
            assertEqual('Driving my Ford, a Model T', new ModelT().drive());
        }},
        
        testDoubleSuperCall: function() { with(this) {
            assertEqual('talktalk', new Bar().talk());
        }},
        
        testSingletonMethodInheritance: function() { with(this) {
            var rex = new Bear('rex');
            rex.extend({speak: function() {
                return 'Guess what? ' + this.callSuper();
            }});
            assertEqual('Guess what? MY NAME IS REX AND I LIKE WALKS', rex.speak('walks'));
        }},
        
        testInterfaces: function() { with(this) {
            assertRaise('Error', function() {
              JS.Interface.ensure({}, Dog.Interface);
            });
            assert(Dog.Interface.test(new Dog('Rex')));
            assert(!Dog.Interface.test({}));
        }},
        
        testSuperWithNoArguments: function() { with(this) {
            var brutus = new Pitbull('Brutus');
            assertEqual('My name is Brutus and I like biting', brutus.speak('biting'));
        }},
        
        // Avoid Crockford's problem: http://www.ajaxpath.com/javascript-inheritance
        testReassignedSuper: function() { with(this) {
            var top = new TopClass();
            assertEqual('TopClass(2) extends SubClass(2) extends BaseClass(2)', top.getName());
        }},
        
        testInheritanceFromNativeClass: function() { with(this) {
            var nat = new NativeClass();
            assertEqual('Native', nat.getName());
            var child = new ChildOfNativeClass();
            assertEqual('Native', child.getName());
            NativeClass.prototype.shout = function() { return 'Shouting!!'; };
            assertEqual('Shouting!!', child.shout());
            assert(child.isA(ChildOfNativeClass));
            assert(child.isA(NativeClass));
            assert(child.isA(Object));
            assert(!child.isA(Dog));
        }},
        
        testBinding: function() { with(this) {
            var rex = new Dog('Rex');
            var bark = rex.method('bark');
            assertEqual('Rex says WOOF!', bark());
            var brutus = new Pitbull('Brutus');
            assertEqual('Brutus says WOOF!', brutus.bark());
            bark = brutus.bark;
            assertEqual(' says WOOF!', bark());
            var bite = Pitbull.method('canBiteYourLegsOff');
            assertEqual('Of course it can', bite());
        }},
        
        testMethodMemoization: function() { with(this) {
            var dog = new Dog('Oscar');
            var bark = dog.method('bark');
            assertEqual(bark, dog.method('bark'));
            dog.extend({
              bark: function() {
                return this.callSuper() + ' and has his own bark() method.';
              }
            });
            assertEqual('Oscar says WOOF! and has his own bark() method.', dog.bark());
            assert(dog.method('bark') != bark);
            assert(dog.method('bark') == dog.method('bark'));
        }},
        
        testInstanceMethod: function() { with(this) {
            var klass = new JS.Class({
                include: JS.Observable,
                talk: function(){}
            });
            assertEqual(klass.prototype.talk, klass.instanceMethod('talk'));
            assertEqual(JS.Observable.__fns__.subscribe, klass.instanceMethod('subscribe'));
        }},
        
        testHierarchy: function() { with(this) {
            var rex = new Dog('Rex');
            assert(rex.isA(Dog));
            assert(rex.isA(Animal));
            assert(rex.isA(Object));
            assert(!rex.isA(Bear));
            var yogi = new rex.klass.superclass.subclasses[0]('Yogi');
            assertEqual('Yogi', yogi.name);
            assert(yogi.isA(Bear));
            assert(!yogi.isA(Dog));
        }},
        
        testSubclassUpdating: function() { with(this) {
            var kevin = new Koala('Kevin');
            Animal.include({shout: function(thing) {
                return this.name + ' is loving ' + thing + '!!!';
            }});
            assertEqual('Kevin is loving trees!!!', kevin.shout('trees'));
            Animal.extend({count: function() { return 6; }});
            assertEqual(4*6, Koala.count() + Bear.count() + Dog.count() + Pitbull.count());
        }},
        
        testClassMethodsMustBeDeclaredWithExtend: function() { with(this) {
            Dog.eatFood = function(food) { return 'Dogs eat ' + food; };
            assertEqual('Dogs eat biscuits', Dog.eatFood('biscuits'));
            Animal.extend({eatFood: function(food) { return 'Animals eat ' + food; }});
            assertEqual('Animals eat people', Pitbull.eatFood('people'));
            assertEqual('Animals eat biscuits', Dog.eatFood('biscuits'));
        }},
        
        testModularInheritance: function() { with(this) {
            var paginator = new Paginator(12);
            assert(paginator.isA(Paginator));
            assert(paginator.items[6].isA(Paginator.Item));
            assert(paginator.items[6].isA(paginator.items[3].klass));
            assertEqual('Item 7', paginator.items[7].getName());
            
            var gallery = new Gallery(3);
            assertEqual(12, gallery.items.length);
            assert(gallery.isA(Gallery));
            assert(gallery.isA(Paginator));
            assert(gallery.items[5].isA(Gallery.Item));
            assert(gallery.items[5].isA(Paginator.Item));
            
            assert(Paginator.Item === Gallery.Item);
            assert(ItemInheritor.Item !== Gallery.Item);
            assert(ItemInheritor.Item.superclass === Gallery.Item);
            
            var itor = new ItemInheritor(2);
            assertEqual('Item 13', itor.items[6].getName());
        }},
        
        testModuleUpdating: function() { with(this) {
            var Mod1 = new JS.Module();
            var Mod2 = new JS.Module({include: Mod1});
            var klass = new JS.Class({include: Mod2});
            
            Mod2.include({
                theMethod: function() { return 'success!' }
            });
            
            Mod1.include({
                theUpperMethod: function() { return 'success!' }
            });
            
            assertEqual('success!', (new klass).theMethod());
            assertEqual('success!', (new klass).theUpperMethod());
        }},
        
        testModule: function() { with(this) {
            assertEqual('function', typeof BlankClass.find);
            assertEqual('function', typeof BlankClass.create);
            var foo = new BlankClass;
            assertEqual('function', typeof foo.save);
            assertEqual('function', typeof foo.validate);
            assertEqual('function', typeof foo.attributes);
            assertEqual('function', typeof foo.each);
            assertEqual('function', typeof foo.some);
            assertEqual(1, Enum.hasBeenIncluded);
        }},
        
        testSingleton: function() { with(this) {
            var bear = new JS.Singleton(Bear, {
                roar: function() { return this.noise; },
                noise: 'ROAR'
            });
            assertEqual(Bear, bear.klass.superclass);
            var roar = bear.method('roar');
            assertEqual('ROAR', roar());
        }},
        
        testInheritedHook: function() { with(this) {
            var foo = new JS.Class(HookTester, {
                extend: {
                    log: function(klass) {}
                }
            });
            assert(Object.children.length > 0);
            assertEqual(SpecialSub, InheritanceTester.children[0]);
            assertEqual(HookTester, InheritanceTester.children[1]);
            assertEqual(foo, InheritanceTester.children[2]);
        }},
        
        testMethodChain: function() { with(this) {
            var chain = new JS.MethodChain(['foo', 'bar']);
            chain.map(function(s) { return s.toUpperCase() })
                    .join(", ").replace(/[aeiou]/ig, "_");
            assertEqual("F__, B_R", chain.fire());
            assertEqual("S_M_TH_NG, _LS_", chain.fire(['something', 'else']));
            
            var SillyNames = new JS.Class({
                initialize: function() {
                    this.name = arguments[0];
                },
                wollaWollaBingBang: function() {
                    return this.name;
                }
            });
            
            var instance = new SillyNames('something');
            var chain = new JS.MethodChain;
            
            chain.wollaWollaBingBang();
            assertEqual('something', chain.fire(instance));
            
            chain = new JS.MethodChain;
            assertEqual('THE TEXT', chain._(new String('the text')).toUpperCase().fire());
            
            var racoon = new Animal('Racoon');
            assertEqual('THE TEXT', racoon._(new String('the text')).toUpperCase());
            assertEqual('Racoon hides in your TV', racoon._(function(thing) { return this.name + ' ' + thing; }, 'hides in your TV'));
            
            assertEqual('function', typeof it().setState);
        }},
        
        testComparableModule: function() { with(this) {
            var items = [8,2,7,5,3,7,6].map(function(id) { return new TodoItem(id) });
            var sorted = items.clone().sort(TodoItem.compare);
            assertEqual('2,3,5,6,7,7,8', sorted.pluck('position').join(','));
            assert(items[1].lt(items[6]));
            assert(items[3].lte(items[2]));
            assert(items[0].gt(items[4]));
            assert(items[2].gte(items[5]));
            assert(items[5].eq(items[2]));
            assert(items[3].between(items[4], items[2]));
        }},
        
        testEnumerableModule: function() {
            var foo = [1,2,3,4,5,6], results;
            var collection = new Collection(1,2,3,4,5,6);
            var collection2 = new Collection(5,6,7,8);
            
            results = ['1,2,3,4', '2,3,4,5', '3,4,5,6'];
            collection.forEachCons(4, function(set, i) {
                this.assertEqual(results[i], set.join(','));
            }, this);
            
            results = ['1,2,3', '4,5,6', '7,8,9', '10'];
            new Collection(1,2,3,4,5,6,7,8,9,10).forEachSlice(3, function(set, i) {
                this.assertEqual(results[i], set.join(','));
            }, this);
            
            collection.forEach(function(x,i) {
                this.assertEqual(foo[i], x);
            }, this);
            
            this.assertEqual(61, collection.inject(40, function(memo, item) { return memo + item; }));
            this.assertEqual(36, collection.inject(0, function(memo, item, i) { return memo + item + i; }));
            this.assertEqual(21, collection.inject(function(memo, item) { return memo + item; }));
            
            this.x = 4;
            this.assertEqual(81, collection.inject(function(memo, item) { return memo + this.x * item; }, this));
            this.assertEqual(24, collection.inject(-60, function(memo, item) { return memo + this.x * item; }, this));
            
            this.assert(collection.all(function(item, i) { return item == i + 1 }));
            this.assert(collection.member(4));
            this.assert(!collection.member('jam'));
            
            this.assertEqual('1,2', collection.partition(function(x) { return x <= 2 })[0].join(','));
            this.assertEqual('3,4,5,6', collection.partition(function(x) { return x <= 2 })[1].join(','));
            
            this.assert(collection.any(function(item) { return item == 3 }));
            this.assert(!collection.any(function(item, i) { return item == i }));
            this.assert(collection.any(function(item, i) { return item == i + 1 }));
            this.assert(collection.any(function(item) { return item == this.x }, this));
            this.assert(!collection.any(function(item) { return item == 9 }));
            
            this.assertEqual(3, collection.detect(function(x) { return x % 3 === 0 }));
            this.assertEqual(5, collection.find(function(x) { return x % 5 === 0 }));
            this.assertEqual(null, collection.find(function(x) { return x % 12 === 0 }));
            this.assertEqual(4, collection.detect(function(x) { return x * 8 === 32 }));
            
            this.assertEqual('5,6', collection.select(function(x) { return x > 4 }).join(','));
            
            this.assertEqual('1,2,3,4,5,6', collection.entries().join(','));
            
            var zip = collection.zip([8,2,7,6], ['cat', 'dog', 'mouse']);
            results = ['1,8,cat', '2,2,dog', '3,7,mouse', '4,6,', '5,,', '6,,'];
            zip.each(function(item,i) {
                this.assertEqual(results[i], item.join(','));
            }, this);
            
            collection.zip([8,2,7,6], ['cat', 'dog', 'mouse'], function(ary, i) {
                this.assertEqual(results[i], ary.join(','));
            }, this);
            
            zip = collection.zip(collection2);
            results = ['1,5', '2,6', '3,7', '4,8', '5,', '6,'];
            zip.each(function(item,i) {
                this.assertEqual(results[i], item.join(','));
            }, this);
            
            this.assertIdentical(false, new Collection(1,2,3).zip([true, false, true])[1][1]);
            
            collection = new Collection(
                new TodoItem(8, 'Play golf'),
                new TodoItem(5, 'Go to work'),
                new TodoItem(7, 'Make money'),
                new TodoItem(3, 'Have nap'),
                new TodoItem(4, 'Organise to-do list')
            );
            
            this.method = 'compareTo';
            this.assertEqual('3,4,5,7,8', collection.sort().pluck('position').join(','));
            this.assertEqual('Have nap', collection.min().task);
            this.assertEqual('Play golf', collection.max().task);
            this.assertEqual('8,7,5,4,3', collection.sort(function(a,b) { return b[this.method](a) }, this).pluck('position').join(','));
            this.assertEqual(3, collection.max(function(a,b) { return b[this.method](a) }, this).position);
            this.assertEqual(8, new Collection(1,8,3,7,5).max());
            this.assertEqual('comes', new Collection('something', 'wicked', 'comes', 'this', 'way').min());
            this.assertEqual('3,4,5,7,8', new Collection(8,5,7,3,4).sort().join(','));
            this.assertEqual('8,7,5,4,3', new Collection(8,5,7,3,4).sort(function(a,b) { return (1/a) - (1/b) }).join(','));
            
            this.field = 'task';
            this.assertEqual("Go to work, Have nap, Make money, Organise to-do list, Play golf",
                    collection.sortBy(function(item) { return item[this.field]; }, this).pluck('task').join(', '));
            
            this.assertEqual("3,4,5,7,8",
                    collection.sortBy(function(item) { return item; }).pluck('position').join(','));
        },
        
        testHashes: function() {
            var hash1 = new PairedHash({foo: 'foo', bar: 'bar'});
            hash1.inject(function(memo, pair, index) {
                this.assert(pair.key && typeof pair.value == 'string');
                this.assertEqual(undefined, index);
            }, this);
            
            var hash2 = new KeyValueHash({foo: 'foo', bar: 'bar'});
            hash2.inject(function(memo, key, value) {
                this.assert(typeof key == 'string' && typeof value == 'string');
            }, this);
            
            var obj = hash2.inject({}, function(memo, key, value) {
                memo[key] = value.toUpperCase();
                return memo;
            });
            this.assertEqual('FOO', obj.foo);
            this.assertEqual('BAR', obj.bar);
            
            var hash3 = new KeyValueHash({foo: 'foo', bar: 'bar', fizz: 'buzz'});
            this.assert(hash3.any(function(key, value) { return key == value; }));
            this.assert(!hash3.all(function(key, value) { return key == value; }));
            this.assert(hash2.all(function(key, value) { return key == value; }));
            
            this.assertEqual('bar,fizz,foo', hash3.keys().sort().join(','));
            this.assertEqual('bar,buzz,foo', hash3.values().sort().join(','));
        },
        
        testSet: function() { with(this) {
            assert((new JS.Set) instanceof JS.Set);
            assert((new JS.SortedSet) instanceof JS.Set);
            assert((new JS.SortedSet) instanceof JS.SortedSet);
            
            var a = new JS.Set([8,2,7,4,8,1]);
            var b = new JS.Set([3,5,6,9,2,8]);
            assertEqual(5, a.size);
            assertEqual(6, b.size);
            assertEnumEqual([8,2,7,4,1,3,5,6,9], a.u(b).entries());
            assertEqual(JS.Set, a.u(b).klass);
            assertEqual(JS.Set, a.n(b).klass);
            assertEnumEqual([2,8], a.n(b).entries());
            var c = new JS.Set([1,9,2,8,3,7,4,6,5]);
            var cats = c.classify(function(x) { return x % 3 });
            assertEnumEqual([6,3,9], cats[0].entries());
            assertEnumEqual([4,7,1], cats[1].entries());
            assertEnumEqual([5,8,2], cats[2].entries());
            
            var container = new JS.Set;
            container.add(new JS.Set);
            container.add(new JS.SortedSet);
            container.add(new JS.Set);
            assert(container.contains(new JS.Set));
            assertEqual(1, container.size);
            container.add(new JS.SortedSet([12]));
            assertEqual(2, container.size);
            
            container = new JS.SortedSet;
            container.add(new JS.Set);
            container.add(new JS.SortedSet);
            container.add(new JS.Set);
            assert(container.contains(new JS.Set));
            assertEqual(1, container.size);
            
            var list = [9,3,7,8,4];
            var sorted = new JS.SortedSet(['fred', 'baz']);
            var inner = new JS.Set([5, sorted]);
            var nest = new JS.Set([4, 'foo', list, inner, 12, new JS.Set([45,'twelve'])]);
            nest.flatten();
            assertEnumEqual(['twelve',45,12,'fred','baz',5,list,'foo',4], nest.entries());
            assertEnumEqual(['baz', 'fred'], sorted.entries());
            assertEnumEqual([5, sorted], inner.entries());
            
            assertEnumEqual([4,9,8], new JS.Set([8,2,9,4,'foo']).difference(['foo',2]));
            assertEnumEqual([0,1,7], new JS.SortedSet([3,9,4,6]).complement([1,0,3,7,6,9,4]));
            
            var sets = a.u(b).divide(function(x) { return x % 3 });
            assert(sets instanceof JS.Set);
            assert(sets.contains(new JS.Set([6,9,3])));
            assert(sets.contains(new JS.SortedSet([7,1,4])));
            assert(sets.contains(new JS.Set([8,2,5])));
            assertEqual(3, sets.size);
            
            // http://en.wikipedia.org/wiki/Subset
            assert(new JS.Set([1,2]).isProperSubset(new JS.Set([1,2,3])));
            assert(new JS.Set([3,1,2]).isSubset(new JS.Set([1,2,3])));
            assert(!( new JS.Set([3,1,2]).isProperSubset(new JS.Set([1,2,3])) ));
            assert(new JS.SortedSet().isSubset(new JS.Set([1,2,3])));
            
            sets.replace([0,3,8,2]);
            assert(sets.equals(new JS.SortedSet([3,0,2,8])));
            
            c = new JS.Set([8,2,6,5,7]);
            c.remove(2);
            assert(c.equals(new JS.Set([5,6,7,8])));
            c.removeIf(function(x) { return x%2 == 0 });
            assert(c.equals(new JS.Set([5,7])));
            c = new JS.Set([new JS.Set()]);
            assertEqual(1, c.size);
            c.remove(new JS.SortedSet);
            assertEqual(0, c.size);
            
            c = new JS.Set([8,2,6,5,7]);
            c.subtract([7,6]);
            assert(c.equals(new JS.Set([5,8,2])));
            
            var k = new JS.SortedSet([1,2,3,4]), l = new JS.SortedSet([5,6,7,8]);
            assertEqual('1,5,1,6,1,7,1,8,2,5,2,6,2,7,2,8,3,5,3,6,3,7,3,8,4,5,4,6,4,7,4,8',
                    k.x(l).map(function(pair) { return pair.join(',') }).join(','));
            
            var xa = new JS.Set([2,9,3,7,5]), xb = new JS.Set([8,1,5,2,6]);
            var x = xa.xor(xb);
            assert(x.equals(new JS.Set([9,3,7,8,1,6])));
            assert(xa.equals(new JS.Set([2,9,3,7,5])));
            assert(xb.equals(new JS.Set([8,1,5,6,2])));
            
            var s, ary, i, n = 10;
            
            for (i = 0; i < n; i++) {
                ary = new JS.Set( $R(1,20).map(function() {
                    return Math.round(100 * Math.random());
                }) ).entries();
                s = new JS.SortedSet(ary);
                ary.sort(function(a,b) { return a-b });
                assertEnumEqual(ary, s.entries());
            }
            
            s = new JS.SortedSet(a);
            assertEnumEqual([1,2,3,4,5,6,7,8,9], s.u(b).entries());
            assertEqual(JS.SortedSet, s.u(n).klass);
            cats = s.u(b).classify(function(x) { return x % 4 });
            assertEqual(JS.SortedSet, cats[0].klass);
            assertEnumEqual([4,8], cats[0].entries());
            assertEnumEqual([1,5,9], cats[1].entries());
            assertEnumEqual([2,6], cats[2].entries());
            assertEnumEqual([3,7], cats[3].entries());
            
            var todos = $R(1,6).map(function(i) { return new TodoItem(i) });
            s = new JS.SortedSet(todos);
            todos[2].position = 9;
            assertEnumEqual([1,2,9,4,5,6], s.map(function(t) { return t.position }));
            s.rebuild();
            assertEnumEqual([1,2,4,5,6,9], s.map(function(t) { return t.position }));
        }},
        
        testHomogenousSortedSet: function() { with(this) {
            var n= 20;
            var todos = $R(1,n).map(function() { return new TodoItem(5) });
            var set = new JS.SortedSet(todos);
            assertEqual(n, set.size);
            var i = n; while (i--) assert(set.contains(todos[i]));
            
            todos = $R(1,n).map(function(i) { return new TodoItem(i%4) });
            set = new JS.SortedSet(todos);
            i = n; while (i--) assert(set.contains(todos[i]));
            assertEnumEqual([0,0,0,0,0,1,1,1,1,1,2,2,2,2,2,3,3,3,3,3], set.map(function(t) { return t.position }));
        }},
        
        testObservableModule: function() { with(this) {
            var pub = new Publisher;
            this.counter = 0;
            var increment = function() { this.counter++ };
            pub.subscribe(increment, this);
            pub.subscribe(function(x) { this.counter += x }, this);
            pub.notifyObservers(4);
            assertEqual(5, this.counter);
            pub.unsubscribe(increment, this);
            pub.unsubscribe(increment, this);
            pub.notifyObservers(9);
            assertEqual(14, this.counter);
            pub.setChanged(false);
            pub.notifyObservers(905);
            assertEqual(14, this.counter);
            pub.setChanged();
            pub.notifyObservers(905);
            assertEqual(919, this.counter);
            pub.subscribe(increment, this);
            pub.notifyObservers(4);
            assertEqual(924, this.counter);
            pub.unsubscribe(increment);
            pub.notifyObservers(4);
            assertEqual(929, this.counter);
            pub.unsubscribe(increment, this);
            pub.notifyObservers(4);
            assertEqual(933, this.counter);
        }},
        
        testDecorator: function() { with(this) {
            var bike = new Bicycle('BMX', 1);
            var bikeWithHeadlights = new HeadlightDecorator(bike);
            assertEqual(10, bike.getPrice());
            assertEqual(15, bikeWithHeadlights.getPrice());
            assertEqual('BMX', bikeWithHeadlights.getModel());
            
            assert(Bicycle == bikeWithHeadlights.klass);
            
            var mtb = new Bicycle('Mountain bike', 24);
            var mtbWithLights = new HeadlightDecorator(new HeadlightDecorator(mtb));
            assertEqual(250, mtbWithLights.getPrice());
            
            var mtbWithPedalsAndLights = new HeadlightDecorator(new PedalsDecorator(mtb));
            assertEqual(269, mtbWithPedalsAndLights.getPrice());
            assertEqual('Turning the pedals', mtbWithPedalsAndLights.rotatePedals());
            assertEqual(Bicycle, mtbWithPedalsAndLights.klass);
            assertEqual(Bicycle, mtbWithPedalsAndLights.constructor);
        }},
        
        testVirtualProxy: function() { with(this) {
            var instances = 0;
            
            var Car = new JS.Class({
                initialize: function(name) {
                    this.name = name;
                    ++instances;
                },
                getName: function(text) {
                    return this.name + (text || '');
                },
                setName: function() {
                    this.name = $A(arguments).join(', ');
                }
            });
            
            var CarProxy = new JS.Proxy.Virtual(Car);
            
            var car = new CarProxy('Ferrari');
            assert(car.klass == Car);
            assertEqual(0, instances);
            assertEqual('Ferrari is a car', car.getName(' is a car'));
            assertEqual(1, instances);
            car.setName('this', 'is', 'my', 'name');
            assertEqual('this, is, my, name', car.getName());
            assertEqual(1, instances);
            
            car.extend({
                getUpperCaseName: function() {
                    return this.name.toUpperCase();
                }
            });
            
            assertEqual('THIS, IS, MY, NAME', car.getUpperCaseName());
            
            car.extend({
                getName: function() {
                    return this.callSuper().replace(/[aeiou]/ig, '_');
                }
            });
            
            assertEqual('th_s, _s, my, n_m_', car.getName());
        }},
        
        testStatePattern: function() { with(this) {
            var fiddler = new Fiddler();
            assertEqual(0, fiddler.count);
            fiddler.stepForward();
            fiddler.stepForward();
            assertEqual(4, fiddler.count);
            assertEqual('Ha-ha!', fiddler.laughOutLoud());
            fiddler.setState('pessimism');
            assertIdentical(fiddler, fiddler.laughOutLoud());
            fiddler.stepForward();
            fiddler.stepForward();
            assertEqual(2, fiddler.count);
            fiddler.setState(Fiddler.prototype.states.optimism);
            fiddler.stepForward();
            fiddler.stepForward();
            assertEqual(6, fiddler.count);
            fiddler.setState(Fiddler.prototype.states.pessimism);
            assert(fiddler.inState(Fiddler.prototype.states.pessimism));
            assert(fiddler.inState('pessimism'));
            assert(!fiddler.inState('optimism'));
            fiddler.stepForward();
            fiddler.stepForward();
            assertEqual(4, fiddler.count);
        }},
        
        testStateInheritance: function() { with(this) {
            var child = new ChildStateMachine();
            child.setState('ponies');
            assertEqual("Alice likes ponies!", child.speak());
            child.setState('doggies');
            assertEqual("doggies! aren't they cute?", child.speak());
            child = new AnotherChildStateMachine();
            child.setState('ponies');
            assertEqual("Jenny likes ponies! aren't they cute?", child.speak());
            child.setState('poundingTechnoMusic');
            assertEqual('Do you know where your children are?', child.speak());
        }},
        
        testDecoratedStateClass: function() { with(this) {
            var fiddler = new DecoratedFiddler( new Fiddler() );
            assertEqual(0, fiddler.count());
            fiddler.stepForward();
            fiddler.stepForward();
            assertEqual(204, fiddler.count());
            assertEqual('HA-HA!', fiddler.laughOutLoud());
            fiddler.setState('pessimism');
            assertIdentical('WRONG', fiddler.laughOutLoud());
            fiddler.stepForward();
            fiddler.stepForward();
            assertEqual(402, fiddler.count());
            fiddler.setState(DecoratedFiddler.prototype.states.optimism);
            fiddler.stepForward();
            fiddler.stepForward();
            assertEqual(606, fiddler.count());
            fiddler.setState(DecoratedFiddler.prototype.states.pessimism);
            assert(fiddler.inState(DecoratedFiddler.prototype.states.pessimism));
            assert(!fiddler.inState('pessimism'));
            fiddler.setState('pessimism');
            assert(fiddler.inState(Fiddler.prototype.states.pessimism));
            assert(fiddler.inState('pessimism'));
            assert(!fiddler.inState('optimism'));
            fiddler.stepForward();
            fiddler.stepForward();
            assertEqual(804, fiddler.count());
        }},
        
        testStateMethodAvailability: function() { with(this) {
            var klass = new JS.Class({
                states: {
                    foo: {
                        add: function() {}
                    }
                }
            });
            assertEqual('function', typeof new klass().add);
        }},
        
        testForwardable: function() { with(this) {
            var forward = new Forwarder();
            forward.setState('pessimism');
            forward.stepForward();
            forward.stepForward();
            forward.stepForward();
            assertEqual(-3, forward.count());
            forward.setState('optimism');
            forward.stepForward();
            forward.stepForward();
            forward.stepForward();
            assertEqual(3, forward.count());
        }}
    });
        
    </script>
</body>
</html>