<canvas title="lzunit-node" debug="true" >
  <include href="lzunit" />

  <TestSuite>

    <TestCase>

        <method name="testSub">
            var LzSub = Class( "LzSub", null, 
                               function (){ this.testAttr = true; this.accum = ""; } );
            LzSub.prototype.testAttr2 = "foo";
            LzSub.prototype.testMethod = function (a) { accum = accum + a; }
            
            assertEquals("LzSub", LzSub.classname);

            var subInst = new LzSub();
            assertTrue( subInst instanceof LzSub );
            assertEquals( true, subInst.testAttr );
            assertEquals( "foo", subInst.testAttr2 );
            assertEquals( "", subInst.accum );
            subInst.testMethod("bar");
            assertEquals( "bar", subInst.accum );
            subInst.testMethod("baz");
            assertEquals( "barbaz", subInst.accum );
            
            var LzSubSub = Class( "LzSubSub", LzSub, 
                                    function () { 
                                        #pragma "methodName=constructor"
                                        super(); 
                                    } );
            LzSubSub.prototype.testMethod = function (a) { 
                #pragma "methodName=testMethod"
                super.testMethod(a); }

            assertEquals("LzSubSub", LzSubSub.classname);
            
            var sub2Inst = new LzSubSub();
            assertTrue( sub2Inst instanceof LzSub);
            assertTrue( sub2Inst instanceof LzSubSub);
            assertEquals( true, sub2Inst.testAttr );
            assertEquals( "foo", sub2Inst.testAttr2 );
            assertEquals( "", sub2Inst.accum );
            sub2Inst.testMethod("bar");
            assertEquals( "bar", sub2Inst.accum );
            sub2Inst.testMethod("baz");
            assertEquals( "barbaz", sub2Inst.accum );
           
        </method>
        
        <method name="testClassNodeSub">
            var LzNodeSub = Class( "LzNodeSub", LzNode );
            assertEquals("LzNodeSub", LzNodeSub.classname);

            var nodeSubInst = new LzNodeSub();
            assertTrue( nodeSubInst instanceof LzNodeSub );
        </method>
        
        <method name="testUserClass">
            new LzUserClass(canvas, 
                            {parent: "node", 
                             initobj: {attrs: {"extends": "node",
                                               foocalls: 0,
                                               foo: function () { 
                                                 #pragma "methodName=foo"
                                                 this.foocalls++; 
                                                    }}, 
                                       name: "suba"}}, 
                            [], false);
                            
            var suba = _root["suba"];
            
            var insta = new suba(canvas, { name: "insta" }, [], false);
            assertTrue( insta instanceof suba );
            
            assertEquals(0, insta.foocalls);
            insta.foo();
            assertEquals(1, insta.foocalls);

            new LzUserClass(canvas, 
                            {parent: "suba", 
                             initobj: {attrs: {"extends": "suba",
                                               foooverrides: 0,
                                               foo: function() { 
                                                 #pragma "methodName=foo"
                                                 super.foo(); 
                                                 this.foooverrides++; 
                                                    }}, 
                                       name: "subb"}}, 
                            [], false);

            var subb = _root["subb"];

            var instb = new subb(canvas, { name: "instb" }, [], false);
            assertTrue( instb instanceof subb );
            assertTrue( instb instanceof suba );
            
            assertEquals(0, instb.foocalls);
            assertEquals(0, instb.foooverrides);
            instb.foo();
            assertEquals(1, instb.foocalls);
            assertEquals(1, instb.foooverrides);
        </method>
        
        <method name="addTests"> 
            this.addTest("testSub");
            this.addTest("testClassNodeSub");
            this.addTest("testUserClass");
        </method> 
    </TestCase>
    
  </TestSuite>
  
</canvas>