base/tests/base.html

	base.html revision db748fdbe02870b4c78302a13fc95ab765d474c0
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
794b79e6bbc3f5db1ea6ae154d739b9f1ef1a375Tinderbox User<html>
9210d8796eaf4125ac58c034f9b5ca167857a55aAutomatic Updater<head>
4a14ce5ba00ab7bc55c99ffdcf59c7a4ab902721Automatic Updater    <title>Base Tests</title>
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt    <script src="/build/yui/yui.js"></script>
9210d8796eaf4125ac58c034f9b5ca167857a55aAutomatic Updater
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt    <style type="text/css">
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt        #console .yui3-console-entry {
9210d8796eaf4125ac58c034f9b5ca167857a55aAutomatic Updater            padding:2px;
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            margin:0px;
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            min-height:0;
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt        }
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt        #console .yui3-console-entry-fail .yui3-console-entry-cat {
ea94d370123a5892f6c47a97f21d1b28d44bb168Tinderbox User            background-color:red;
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt        }
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt        #console .yui3-console-entry-pass .yui3-console-entry-cat {
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            background-color:green;
852ccdd42a71550c974111b49415204ffeca6573Automatic Updater        }
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt        #console .yui3-console-entry-perf .yui3-console-entry-cat {
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            background-color:blue;
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt        }
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt        #console {
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            position:static;
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt        }
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
ec899c963c91c16c393e067996400ae244921110Tinderbox User        html, body {
ec899c963c91c16c393e067996400ae244921110Tinderbox User            height:100%;
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt        }
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt    </style>
ec899c963c91c16c393e067996400ae244921110Tinderbox User</head>
ec899c963c91c16c393e067996400ae244921110Tinderbox User<body class="yui3-skin-sam">
ec899c963c91c16c393e067996400ae244921110Tinderbox User<div id="testbed" class="yui3-skin-foo"></div>
f5ae3cca1d2832239cc821bdef77e90c1739e66dTinderbox User<script>
ec899c963c91c16c393e067996400ae244921110Tinderbox UserYUI({
ec899c963c91c16c393e067996400ae244921110Tinderbox User    useBrowserConsole:false,
ec899c963c91c16c393e067996400ae244921110Tinderbox User    filter: (window.location.search.match(/[?&]filter=([^&]+)/) || [])[1] || 'min'
ec899c963c91c16c393e067996400ae244921110Tinderbox User}).use('test', 'base', 'console', function (Y) {
ec899c963c91c16c393e067996400ae244921110Tinderbox User
ec899c963c91c16c393e067996400ae244921110Tinderbox User    // NOTE: Attribute's unit tests cover a large section of Base's functionality when it comes to dealing with attributes.
ec899c963c91c16c393e067996400ae244921110Tinderbox User
ec899c963c91c16c393e067996400ae244921110Tinderbox User    var suite = new Y.Test.Suite("Base Tests");
ec899c963c91c16c393e067996400ae244921110Tinderbox User
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt    suite.add(new Y.Test.Case({
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
ec899c963c91c16c393e067996400ae244921110Tinderbox User        name : "BaseBuild",
ec899c963c91c16c393e067996400ae244921110Tinderbox User
ec899c963c91c16c393e067996400ae244921110Tinderbox User        "test:create-basic": function () {
ec899c963c91c16c393e067996400ae244921110Tinderbox User
ec899c963c91c16c393e067996400ae244921110Tinderbox User            var expectedMethodCalls = [
ec899c963c91c16c393e067996400ae244921110Tinderbox User                "ext1::constructor",
ec899c963c91c16c393e067996400ae244921110Tinderbox User                "myClass::initializer",
ec899c963c91c16c393e067996400ae244921110Tinderbox User                "ext1::constructor",
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                "myClass::initializer",
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                "myClass::methodOne",
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                "myClass::methodOne",
ec899c963c91c16c393e067996400ae244921110Tinderbox User                "ext1::extOne",
ec899c963c91c16c393e067996400ae244921110Tinderbox User                "ext1::extOne"],
ec899c963c91c16c393e067996400ae244921110Tinderbox User
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                actualMethodCalls = [];
ec899c963c91c16c393e067996400ae244921110Tinderbox User
ec899c963c91c16c393e067996400ae244921110Tinderbox User            function Ext1() {
ec899c963c91c16c393e067996400ae244921110Tinderbox User                actualMethodCalls.push("ext1::constructor");
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            }
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            Ext1.prototype.extOne = function() {
ec899c963c91c16c393e067996400ae244921110Tinderbox User                actualMethodCalls.push("ext1::extOne");
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            };
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            var MyClass = Y.Base.create("myClass", Y.Base, [Ext1], {
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                initializer: function() {
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                    actualMethodCalls.push("myClass::initializer");
ec899c963c91c16c393e067996400ae244921110Tinderbox User                },
ec899c963c91c16c393e067996400ae244921110Tinderbox User
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                methodOne: function() {
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                    actualMethodCalls.push("myClass::methodOne");
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                }
ec899c963c91c16c393e067996400ae244921110Tinderbox User
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            }, {
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                STATIC_ONE: "static_one"
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            });
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
7ae7246a6339bb3a79ffc9f2f9c486de9a2bf65eAutomatic Updater            // using 2 instances, just to make sure nothing static/prototype related gets broken by the 1st instance
2cbb4ab75757fbb656997a82c14ca07db37d481aAutomatic Updater            var o1 = new MyClass({foo:true});
7ae7246a6339bb3a79ffc9f2f9c486de9a2bf65eAutomatic Updater            var o2 = new MyClass({foo:true});
7ae7246a6339bb3a79ffc9f2f9c486de9a2bf65eAutomatic Updater
7ae7246a6339bb3a79ffc9f2f9c486de9a2bf65eAutomatic Updater            Y.Assert.isFunction(o1.extOne, "Extension method extOne not found on o1");
7ae7246a6339bb3a79ffc9f2f9c486de9a2bf65eAutomatic Updater            Y.Assert.isFunction(o2.extOne, "Extension method extOne not found on o2");
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            Y.Assert.isFunction(o1.methodOne, "Prototype method methodOne not found on o1");
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            Y.Assert.isFunction(o2.methodOne, "Prototype method methodOne not found on o2");
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            Y.Assert.areEqual(o1.constructor.STATIC_ONE, "static_one", "STATIC_ONE not found on o1's constructor");
ec899c963c91c16c393e067996400ae244921110Tinderbox User            Y.Assert.areEqual(o2.constructor.STATIC_ONE, "static_one", "STATIC_ONE not found on o2's constructor");
ec899c963c91c16c393e067996400ae244921110Tinderbox User
ec899c963c91c16c393e067996400ae244921110Tinderbox User            Y.Assert.areEqual(o1.constructor.NAME, "myClass", "NAME not found on o1's constructor");
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            Y.Assert.areEqual(o2.constructor.NAME, "myClass", "NAME not found on o2's constructor");
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            o1.methodOne();
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            o2.methodOne();
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            o1.extOne();
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            o2.extOne();
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            Y.ArrayAssert.itemsAreEqual(expectedMethodCalls, actualMethodCalls, "Unexpected method calls");
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt        },
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt        "test:mix-basic": function() {
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
7ae7246a6339bb3a79ffc9f2f9c486de9a2bf65eAutomatic Updater            var expectedMethodCalls = [
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                "myClass::constructor",
ec899c963c91c16c393e067996400ae244921110Tinderbox User                "ext1::constructor",
ec899c963c91c16c393e067996400ae244921110Tinderbox User                "myClass::initializer",
ec899c963c91c16c393e067996400ae244921110Tinderbox User                "myClass::constructor",
ec899c963c91c16c393e067996400ae244921110Tinderbox User                "ext1::constructor",
ec899c963c91c16c393e067996400ae244921110Tinderbox User                "myClass::initializer",
ec899c963c91c16c393e067996400ae244921110Tinderbox User                "myClass::methodOne",
2cbb4ab75757fbb656997a82c14ca07db37d481aAutomatic Updater                "myClass::methodOne",
2cbb4ab75757fbb656997a82c14ca07db37d481aAutomatic Updater                "ext1::extOne",
2cbb4ab75757fbb656997a82c14ca07db37d481aAutomatic Updater                "ext1::extOne"],
2cbb4ab75757fbb656997a82c14ca07db37d481aAutomatic Updater
7ae7246a6339bb3a79ffc9f2f9c486de9a2bf65eAutomatic Updater                actualMethodCalls = [];
7ae7246a6339bb3a79ffc9f2f9c486de9a2bf65eAutomatic Updater
7ae7246a6339bb3a79ffc9f2f9c486de9a2bf65eAutomatic Updater            function Ext1() {
ec899c963c91c16c393e067996400ae244921110Tinderbox User                actualMethodCalls.push("ext1::constructor");
ec899c963c91c16c393e067996400ae244921110Tinderbox User            }
ec899c963c91c16c393e067996400ae244921110Tinderbox User
7ae7246a6339bb3a79ffc9f2f9c486de9a2bf65eAutomatic Updater            Ext1.prototype.extOne = function() {
7ae7246a6339bb3a79ffc9f2f9c486de9a2bf65eAutomatic Updater                actualMethodCalls.push("ext1::extOne");
ec899c963c91c16c393e067996400ae244921110Tinderbox User            };
ec899c963c91c16c393e067996400ae244921110Tinderbox User
ec899c963c91c16c393e067996400ae244921110Tinderbox User            function MyClass(config) {
2cbb4ab75757fbb656997a82c14ca07db37d481aAutomatic Updater                actualMethodCalls.push("myClass::constructor");
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                MyClass.superclass.constructor.apply(this, arguments);
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            }
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            Y.extend(MyClass, Y.Base, {
ec899c963c91c16c393e067996400ae244921110Tinderbox User
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                initializer: function() {
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                    actualMethodCalls.push("myClass::initializer");
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                },
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                methodOne: function() {
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                    actualMethodCalls.push("myClass::methodOne");
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                }
ec899c963c91c16c393e067996400ae244921110Tinderbox User
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            }, {
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                STATIC_ONE: "static_one",
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt                NAME: "myClass"
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt            });
351b62535d4c4f89883bfdba025999dd32490266Evan Hunt
            Y.Base.mix(MyClass, [Ext1]);

            // using 2 instances, just to make sure nothing static/prototype related gets broken by the 1st instance
            var o1 = new MyClass();
            var o2 = new MyClass();

            Y.Assert.isFunction(o1.extOne, "Extension method extOne not found on o1");
            Y.Assert.isFunction(o2.extOne, "Extension method extOne not found on o2");

            Y.Assert.isFunction(o1.methodOne, "Prototype method methodOne not found on o1");
            Y.Assert.isFunction(o2.methodOne, "Prototype method methodOne not found on o2");

            Y.Assert.areEqual(o1.constructor.STATIC_ONE, "static_one", "STATIC_ONE not found on o1's constructor");
            Y.Assert.areEqual(o2.constructor.STATIC_ONE, "static_one", "STATIC_ONE not found on o2's constructor");

            o1.methodOne();
            o2.methodOne();

            o1.extOne();
            o2.extOne();

            Y.ArrayAssert.itemsAreEqual(expectedMethodCalls, actualMethodCalls, "Unexpected method calls");
        },

        "test:initializer": function() {
            var expectedMethodCalls = [
                "ext1::constructor",
                "myClass::initializer",
                "ext1::initializer",
                "ext1::constructor",
                "myClass::initializer",
                "ext1::initializer"],

                actualMethodCalls = [];

            function Ext1(cfg) {
                actualMethodCalls.push("ext1::constructor");
                Y.Assert.isNotUndefined(cfg);
            }

            Ext1.prototype.initializer = function(cfg) {
                actualMethodCalls.push("ext1::initializer");
                Y.Assert.isNotUndefined(cfg);
            };

            var MyClass = Y.Base.create("myClass", Y.Base, [Ext1], {
                initializer: function(cfg) {
                    actualMethodCalls.push("myClass::initializer");
                    Y.Assert.isNotUndefined(cfg);
                }
            });

            // using 2 instances, just to make sure nothing static/prototype related gets broken by the 1st instance
            var o1 = new MyClass({foo:true});
            var o2 = new MyClass({foo:true});

            Y.ArrayAssert.itemsAreEqual(expectedMethodCalls, actualMethodCalls, "Unexpected method calls");
        },

        "test:destructor": function() {
            var expectedMethodCalls = [
                "ext1::destructor",
                "myClass::destructor",
                "ext1::destructor",
                "myClass::destructor"],

                actualMethodCalls = [];

            function Ext1(cfg) {}

            Ext1.prototype.destructor = function(cfg) {
                actualMethodCalls.push("ext1::destructor");
            };

            var MyClass = Y.Base.create("myClass", Y.Base, [Ext1], {
                destructor: function(cfg) {
                    actualMethodCalls.push("myClass::destructor");
                }
            });

            // using 2 instances, just to make sure nothing static/prototype related gets broken by the 1st instance
            var o1 = new MyClass({foo:true});
            var o2 = new MyClass({foo:true});

            o1.destroy();
            o2.destroy();

            Y.ArrayAssert.itemsAreEqual(expectedMethodCalls, actualMethodCalls, "Unexpected method calls");
        },

        "test:attrs" : function() {

            var actualMethodCalls = [],
                expectedMethodCalls = [
                    "ext1::attr2::setter", // once for lazy o1 - This was news to me: we should optimize it as part off Attr performance
                    "ext1::attr2::setter", // once for set o1
                    "ext1::attr2::setter", // once for lazy o2
                    "ext1::attr2::setter"  // once for set o2
                ];

            function Ext1() {}

            Ext1.ATTRS = {
                attr1 : {
                    value:"attr1-ext1"
                },
                attr2 : {
                    value:"attr2-ext1",
                    setter: function(val) {
                        actualMethodCalls.push("ext1::attr2::setter");
                        return val;
                    }
                },
                attr3: {
                    value:"attr3-ext1"
                }
            };

            var MyClass = Y.Base.create("myClass", Y.Base, [Ext1]);

            // using 2 instances, just to make sure nothing static/prototype related gets broken by the 1st instance
            var o1 = new MyClass();
            var o2 = new MyClass();

            o1.set("attr2", "foo");
            o2.set("attr2", "foo");

            Y.Assert.areEqual("attr1-ext1", o1.get("attr1"), "o1 attr1 incorrect");
            Y.Assert.areEqual("attr1-ext1", o2.get("attr1"), "o2 attr1 incorrect");

            Y.Assert.areEqual("foo", o1.get("attr2"), "o1 attr2 incorrect");
            Y.Assert.areEqual("foo", o2.get("attr2"), "o2 attr2 incorrect");

            Y.Assert.areEqual("attr3-ext1", o1.get("attr3"), "o1 attr3 incorrect");
            Y.Assert.areEqual("attr3-ext1", o2.get("attr3"), "o2 attr3 incorrect");

            Y.ArrayAssert.itemsAreEqual(expectedMethodCalls, actualMethodCalls, "Unexpected method calls");
        },

        "test:aggregates" : function() {

            function Ext1() {}

            Ext1.HTML_PARSER = {
                a:"aa",
                b:"bb"
            };

            function MyWidget(config) {
                MyWidget.superclass.constructor.apply(this, arguments);
            }

            Y.extend(MyWidget, Y.Base, {}, {

                HTML_PARSER : {
                    a:"a"
                },

                _buildCfg : {
                    aggregates : ["HTML_PARSER"]
                }
            });

            var MyClass = Y.Base.create("myClass", MyWidget, [Ext1]);

            // using 2 instances, just to make sure nothing static/prototype related gets broken by the 1st instance
            var o1 = new MyClass();
            var o2 = new MyClass();

            Y.ObjectAssert.areEqual({a:"aa", b:"bb"}, o1.constructor.HTML_PARSER, "o1 HTML_PARSER not aggregated correctly");
            Y.ObjectAssert.areEqual({a:"aa", b:"bb"}, o2.constructor.HTML_PARSER, "o2 HTML_PARSER not aggregated correctly");

        },

        "test:overrides-ext-wins" : function() {

            var actualMethodCalls = [],
                expectedMethodCalls = [
                    "ext1::attr2::setter", // once for lazy o1
                    "ext1::attr2::setter", // once for set o1
                    "ext1::attr2::setter", // once for lazy o2
                    "ext1::methodOne",
                    "ext1::methodOne"
                ];

            function Ext1() {}

            Ext1.prototype.methodOne = function() {
                actualMethodCalls.push("ext1::methodOne");
            };

            Ext1.ATTRS = {
                attr1 : {
                    value:"attr1-ext1"
                },
                attr2 : {
                    value:"attr2-ext1",
                    setter: function(val) {
                        actualMethodCalls.push("ext1::attr2::setter");
                        return val;
                    }
                },
                attr3: {
                    value:"attr3-ext1"
                }
            };

            function MyClass() {
                MyClass.superclass.constructor.apply(this, arguments);
            }

            MyClass.NAME = "myClass";

            MyClass.ATTRS = {
                attr1 : {
                    value:"attr1-myClass"
                },
                attr2 : {
                    value:"attr2-myClass",
                    setter: function(val) {
                        actualMethodCalls.push("myClass::attr2::setter");
                        return val;
                    }
                },
                attr4 : {
                    value:"attr4-myClass"
                }
            };

            Y.extend(MyClass, Y.Base, {
                methodOne : function() {
                    actualMethodCalls.push("myClass::methodOne");
                }
            });
            Y.Base.mix(MyClass, [Ext1]);

            // using 2 instances, just to make sure nothing static/prototype related gets broken by the 1st instance
            var o1 = new MyClass();
            var o2 = new MyClass();

            // only set o1
            o1.set("attr2", "foo");

            Y.Assert.areEqual("attr1-ext1", o1.get("attr1"), "o1 attr1 incorrect");
            Y.Assert.areEqual("attr1-ext1", o2.get("attr1"), "o2 attr1 incorrect");

            Y.Assert.areEqual("foo", o1.get("attr2"), "o1 attr2 incorrect");
            Y.Assert.areEqual("attr2-ext1", o2.get("attr2"), "o2 attr2 incorrect");

            Y.Assert.areEqual("attr3-ext1", o1.get("attr3"), "o1 attr3 incorrect");
            Y.Assert.areEqual("attr3-ext1", o2.get("attr3"), "o2 attr3 incorrect");

            Y.Assert.areEqual("attr4-myClass", o1.get("attr4"), "o1 attr4 incorrect");
            Y.Assert.areEqual("attr4-myClass", o2.get("attr4"), "o2 attr4 incorrect");

            o1.methodOne();
            o2.methodOne();

            Y.ArrayAssert.itemsAreEqual(expectedMethodCalls, actualMethodCalls, "Unexpected method calls");
        },

        "test:overrides-host-wins" : function() {

            var actualMethodCalls = [],
                expectedMethodCalls = [
                    "myClass::attr2::setter", // once for lazy o1
                    "myClass::attr2::setter", // once for set o1
                    "myClass::attr2::setter", // once for lazy o2
                    "myClass::methodOne",
                    "myClass::methodOne"
                ];

            function Ext1() {}

            Ext1.prototype.methodOne = function() {
                actualMethodCalls.push("ext1::methodOne");
            };

            Ext1.ATTRS = {
                attr1 : {
                    value:"attr1-ext1"
                },
                attr2 : {
                    value:"attr2-ext1",
                    setter: function(val) {
                        actualMethodCalls.push("ext1::attr2::setter");
                        return val;
                    }
                },
                attr3: {
                    value:"attr3-ext1"
                }
            };

            var MyClass = Y.Base.create("myClass", Y.Base, [Ext1], {
                methodOne : function() {
                    actualMethodCalls.push("myClass::methodOne");
                }
            }, {
                ATTRS : {
                    attr1 : {
                        value:"attr1-myClass"
                    },
                    attr2 : {
                        value:"attr2-myClass",
                        setter: function(val) {
                            actualMethodCalls.push("myClass::attr2::setter");
                            return val;
                        }
                    },
                    attr4 : {
                        value:"attr4-myClass"
                    }
                }
            });

            // Using 2 instances, just to make sure nothing static/prototype related gets broken by the 1st instance
            var o1 = new MyClass();
            var o2 = new MyClass();

            // only set o1
            o1.set("attr2", "foo");

            Y.Assert.areEqual("attr1-myClass", o1.get("attr1"), "o1 attr1 incorrect");
            Y.Assert.areEqual("attr1-myClass", o2.get("attr1"), "o2 attr1 incorrect");

            Y.Assert.areEqual("foo", o1.get("attr2"), "o1 attr2 incorrect");
            Y.Assert.areEqual("attr2-myClass", o2.get("attr2"), "o2 attr2 incorrect");

            Y.Assert.areEqual("attr3-ext1", o1.get("attr3"), "o1 attr3 incorrect");
            Y.Assert.areEqual("attr3-ext1", o2.get("attr3"), "o2 attr3 incorrect");

            Y.Assert.areEqual("attr4-myClass", o1.get("attr4"), "o1 attr4 incorrect");
            Y.Assert.areEqual("attr4-myClass", o2.get("attr4"), "o2 attr4 incorrect");

            o1.methodOne();
            o2.methodOne();

            Y.ArrayAssert.itemsAreEqual(expectedMethodCalls, actualMethodCalls, "Unexpected method calls");
        },

        "test:multiext-complex" : function() {

            var actualMethodCalls = [],
                expectedMethodCalls = [
                    "ext1::constructor",
                    "ext2::constructor",
                    "myClass::initializer",
                    "ext1::initializer",
                    "ext2::initializer",
                    "ext1::constructor",
                    "ext2::constructor",
                    "myClass::initializer",
                    "ext1::initializer",
                    "ext2::initializer",
                    "ext2::attr3::setter",
                    "ext2::attr3::setter",
                    "myClass::methodOne",
                    "myClass::methodOne",
                    "myClass::methodTwo",
                    "myClass::methodTwo",
                    "ext2::methodThree",
                    "ext2::methodThree",
                    "ext2::methodFour",
                    "ext2::methodFour",
                    "myClass::methodFive",
                    "myClass::methodFive"
                ];

            function Ext1() {
                actualMethodCalls.push("ext1::constructor");
            }

            Ext1.prototype.initializer = function() {
                actualMethodCalls.push("ext1::initializer");
            };

            Ext1.prototype.methodTwo = function() {
                actualMethodCalls.push("ext1::methodTwo");
            };

            Ext1.prototype.methodThree = function() {
                actualMethodCalls.push("ext1::methodThree");
            };

            Ext1.ATTRS = {
                attr2 : {
                    value:"ext1-attr2"
                },
                attr3 : {
                    value:"ext1-attr3",
                    setter: function(val) {
                        actualMethodCalls.push("ext1::attr3::setter");
                        return val;
                    }
                },
                attr4: {
                    value:"ext1-attr4"
                }
            };

            function Ext2() {
                actualMethodCalls.push("ext2::constructor");
            }

            Ext2.prototype.initializer = function() {
                actualMethodCalls.push("ext2::initializer");
            };

            Ext2.prototype.methodThree = function() {
                actualMethodCalls.push("ext2::methodThree");
            };

            Ext2.prototype.methodFour = function() {
                actualMethodCalls.push("ext2::methodFour");
            };

            Ext2.ATTRS = {
                attr3 : {
                    value:"ext2-attr3",
                    setter: function(val) {
                        actualMethodCalls.push("ext2::attr3::setter");
                        return val;
                    }
                },
                attr4 : {
                    value:"ext2-attr4"
                }
            };

            var MyClass = Y.Base.create("myClass", Y.Base, [Ext1, Ext2], {

                initializer: function() {
                    actualMethodCalls.push("myClass::initializer");
                },

                methodOne : function() {
                    actualMethodCalls.push("myClass::methodOne");
                },

                methodTwo : function() {
                    actualMethodCalls.push("myClass::methodTwo");
                },

                methodFive : function() {
                    actualMethodCalls.push("myClass::methodFive");
                }
            }, {
                ATTRS : {
                    attr1 : {
                        value:"myClass-attr1"
                    },
                    attr5 : {
                        value:"myClass-attr5"
                    }
                }
            });

            var o1 = new MyClass();
            var o2 = new MyClass();

            Y.Assert.areEqual("myClass-attr1", o1.get("attr1"), "o1 attr1 incorrect");
            Y.Assert.areEqual("myClass-attr1", o2.get("attr1"), "o2 attr1 incorrect");

            Y.Assert.areEqual("ext1-attr2", o1.get("attr2"), "o1 attr2 incorrect");
            Y.Assert.areEqual("ext1-attr2", o2.get("attr2"), "o2 attr2 incorrect");

            Y.Assert.areEqual("ext2-attr3", o1.get("attr3"), "o1 attr3 incorrect");
            Y.Assert.areEqual("ext2-attr3", o2.get("attr3"), "o2 attr3 incorrect");

            Y.Assert.areEqual("ext2-attr4", o1.get("attr4"), "o1 attr4 incorrect");
            Y.Assert.areEqual("ext2-attr4", o2.get("attr4"), "o2 attr4 incorrect");

            Y.Assert.areEqual("myClass-attr5", o1.get("attr5"), "o1 attr5 incorrect");
            Y.Assert.areEqual("myClass-attr5", o2.get("attr5"), "o2 attr5 incorrect");

            o1.methodOne();
            o2.methodOne();
            o1.methodTwo();
            o2.methodTwo();
            o1.methodThree();
            o2.methodThree();
            o1.methodFour();
            o2.methodFour();
            o1.methodFive();
            o2.methodFive();

            Y.ArrayAssert.itemsAreEqual(expectedMethodCalls, actualMethodCalls, "Unexpected method calls");
        },

        "test:classstructure" : function() {
            function Ext1() {}
            Ext1.prototype.extOne = function() {};

            function Ext2() {}
            Ext2.prototype.extTwo = function() {};

            var MyClassTwo = Y.Base.create("myClassTwo", Y.Base, [Ext1, Ext2], {
                initializer: function() {},
                methodOne: function() {}
            });

            var MyClassOne = Y.Base.create("myClassOne", Y.Base, [Ext1], {
                initializer: function() {},
                methodOne: function() {}
            });

            var o1 = new MyClassOne();
            var o2 = new MyClassTwo();

            Y.Assert.isTrue(o1.hasImpl(Ext1), "o1 should pass hasImpl(Ext1)");
            Y.Assert.isFalse(o1.hasImpl(Ext2),  "o1 should fail hasImpl(Ext2)");

            Y.Assert.isTrue(o2.hasImpl(Ext1),  "o2 should pass hasImpl(Ext1)");
            Y.Assert.isTrue(o2.hasImpl(Ext2), "o2 should pass hasImpl(Ext1)");

            Y.Assert.isTrue(o1 instanceof MyClassOne, "o1 should be an instanceof MyClassOne");
            Y.Assert.isTrue(o1 instanceof Y.Base, "o1 should be an instanceof Base");

            Y.Assert.isTrue(o2 instanceof MyClassTwo, "o2 should be an instanceof MyClassTwo");
            Y.Assert.isTrue(o2 instanceof Y.Base, "o2 should be an instanceof Base");

            Y.Assert.isFalse(o1 instanceof MyClassTwo, "o1 should NOT be an instanceof MyClassTwo");
            Y.Assert.isFalse(o2 instanceof MyClassOne, "o2 should NOT be an instanceof MyClassOne");

            Y.Assert.isFunction(o1.methodOne, "o1 should have a methodOne method");
            Y.Assert.isFunction(o1.extOne, "o1 should have an extOne method");
            Y.Assert.isUndefined(o1.extTwo, "o1 should not have an extTwo method");

            Y.Assert.isFunction(o2.methodOne, "o2 should have a methodOne method");
            Y.Assert.isFunction(o2.extOne, "o2 should have an extOne method");
            Y.Assert.isFunction(o2.extTwo, "o2 should have an extTwo method");

            Y.Assert.isTrue(MyClassOne.superclass.constructor === Y.Base, "MyClassOne should have superclass set to Base");
            Y.Assert.isTrue(MyClassTwo.superclass.constructor === Y.Base, "MyClassTwo should have superclass set to Base");

            // Make sure Y.Base was untouched.
            var b = new Y.Base();

            Y.Assert.isUndefined(b.methodOne, "Base should not have extension methods");
            Y.Assert.isUndefined(b.extOne, "Base should not have extension methods");
            Y.Assert.isUndefined(b.extTwo, "Base should not have extension methods");
            Y.Assert.isFalse(MyClassOne === Y.Base);
            Y.Assert.isFalse(MyClassTwo === Y.Base);
        },

        "test:mutli-inheritance-from-base" : function() {

            var actualMethodCalls = [],
                expectedMethodCalls = [
                    "myClassOne::initializer",
                    10,
                    "myExt::initializer",
                    "myClassOne::afterInit"
                ];

            var Ext1 = Y.Base.create("myExt", Y.Base, [], {

                initializer: function() {
                    actualMethodCalls.push("myExt::initializer");
                }

            });

            var MyClassOne = Y.Base.create("myClassOne", Y.Base, [Ext1], {

                initializer: function() {
                    actualMethodCalls.push("myClassOne::initializer");
                    actualMethodCalls.push(this.get("myAttr"));
                }

            }, {
                ATTRS : {
                    myAttr: {
                        value: 10
                    }
                }
            });

            var o = new MyClassOne( {
                after: {
                    init: function() {
                        actualMethodCalls.push("myClassOne::afterInit");
                    }
                }
            });

            Y.ArrayAssert.itemsAreEqual(expectedMethodCalls, actualMethodCalls, "Unexpected method calls");

        },

        "test:extend" : function() {

            var actualMethodCalls = [],
                expectedMethodCalls = [
                    "ext1::constructor",
                    "myClassOne::initializer",
                    "ext1::initializer",
                    "ext2::constructor",
                    "myClassTwo::initializer",
                    "ext2::initializer",
                    "myClassOne::methodOne",
                    "myClassTwo::methodTwo",
                    "ext1::extOne",
                    "ext2::extTwo"
                ];

            function Ext1() {
                actualMethodCalls.push("ext1::constructor");
            }
            Ext1.prototype.extOne = function() {
                actualMethodCalls.push("ext1::extOne");
            };
            Ext1.prototype.initializer = function() {
                actualMethodCalls.push("ext1::initializer");
            };

            function Ext2() {
                actualMethodCalls.push("ext2::constructor");
            }
            Ext2.prototype.extTwo = function() {
                actualMethodCalls.push("ext2::extTwo");
            };
            Ext2.prototype.initializer = function() {
                actualMethodCalls.push("ext2::initializer");
            };

            var MyClassOne = Y.Base.create("myClassOne", Y.Base, [Ext1], {
                initializer: function() {
                    actualMethodCalls.push("myClassOne::initializer");
                },
                methodOne: function() {
                    actualMethodCalls.push("myClassOne::methodOne");
                }
            });

            var MyClassTwo = Y.Base.create("myClassTwo", MyClassOne, [Ext2], {
                initializer: function() {
                    actualMethodCalls.push("myClassTwo::initializer");
                },
                methodTwo: function() {
                    actualMethodCalls.push("myClassTwo::methodTwo");
                }
            });

            var o = new MyClassTwo();
            o.methodOne();
            o.methodTwo();
            o.extOne();
            o.extTwo();

            Y.ArrayAssert.itemsAreEqual(expectedMethodCalls, actualMethodCalls, "Unexpected method calls");
        },

        "test:extCfg-statics" : function() {
            function Ext1() {}

            Ext1.prototype.extOne = function() {};
            Ext1.prototype.initializer = function() {};
            Ext1.prototype.methodOne = function() {
                return "methodOne";
            };

            Ext1.STATIC_ONE = "static_one";
            Ext1.STATIC_TWO = "static_two";
            Ext1.STATIC_THREE = "static_three";

            Ext1._buildCfg = {
                statics: ["STATIC_ONE", "STATIC_TWO"]
            };

            var MyClass = Y.Base.create("myClass", Y.Base, [Ext1]);

            var myclass = new MyClass();

            Y.Assert.isTrue(myclass instanceof MyClass);

            Y.Assert.isFunction(myclass.methodOne); // prototype properties copied
            Y.Assert.isFunction(myclass.init); // but prototype not switched completely by mistake as part of statics:true

            Y.Assert.areEqual("static_one", MyClass.STATIC_ONE);
            Y.Assert.areEqual("static_two", MyClass.STATIC_TWO);
            Y.Assert.isFalse("STATIC_THREE" in MyClass);

            Y.Assert.isFalse(MyClass.ATTRS === Ext1.ATTRS, "Ext1.ATTRS shouldn't have been copied over");
        },

        "test:extCfg-aggregates" : function() {

            function Ext1() {}
            Ext1.prototype.extOne = function() {};
            Ext1.prototype.methodOne = function() {
                return "methodOne";
            };

            Ext1.AGGREGATE_ONE = {
                a: 1,
                b: 2,
                c: 3
            };

            Ext1._buildCfg = {
                aggregates: ["AGGREGATE_ONE"]
            };

            function Ext2() {}
            Ext2.prototype.extTwo = function() {};
            Ext2.prototype.methodTwo = function() {
                return "methodTwo";
            };

            Ext2.AGGREGATE_ONE = {
                c:33,
                d:4
            };

            var MyClass1 = Y.Base.create("myClass1", Y.Base, [Ext1]);
            var myclass1 = new MyClass1();

            Y.Assert.isTrue(myclass1 instanceof MyClass1);

            Y.Assert.isFunction(myclass1.methodOne); // prototype properties copied
            Y.Assert.isFunction(myclass1.init); // but prototype not switched completely by mistake as part of statics:true

            Y.ObjectAssert.areEqual({
                a:1,
                b:2,
                c:3
            }, MyClass1.AGGREGATE_ONE);

            Y.Assert.isFalse(MyClass1.AGGREGATE_ONE === Ext1.AGGREGATE_ONE, "Ext1.AGGREGATE_ONE shouldn't have been copied over");

            Y.Assert.isFalse(MyClass1.ATTRS === Ext1.ATTRS, "Ext1.ATTRS shouldn't have been copied over with statics:true");

            var MyClass2 = Y.Base.create("myClass2", Y.Base, [Ext1, Ext2]);
            var myclass2 = new MyClass2();

            Y.Assert.isTrue(myclass2 instanceof MyClass2);

            Y.Assert.isFunction(myclass2.methodTwo); // prototype properties copied
            Y.Assert.isFunction(myclass2.init); // but prototype not switched completely by mistake

            Y.ObjectAssert.areEqual({
                a:1,
                b:2,
                c:33,
                d:4
            }, MyClass2.AGGREGATE_ONE);

            Y.Assert.isFalse(MyClass2.AGGREGATE_ONE === Ext1.AGGREGATE_ONE, "Ext1.AGGREGATE_ONE shouldn't have been copied over");
            Y.Assert.isFalse(MyClass2.AGGREGATE_ONE === Ext2.AGGREGATE_ONE, "Ext2.AGGREGATE_ONE shouldn't have been copied over");
        },

        "test:extCfg-custom" : function() {

            function Ext1() {}

            Ext1.prototype.extOne = function() {};
            Ext1.prototype.methodOne = function() {
                return "methodOne";
            };

            Ext1.CUST = {
                foo: [1],
                bar: [1]
            };

            Ext1._buildCfg = {
                custom : {
                    CUST : function(p, r, s) {

                        r[p] = r[p] || {
                            foo:[],
                            bar:[]
                        };

                        if (s[p]) {
                            if (s[p].foo) {
                                r[p].foo = r[p].foo.concat(s[p].foo);
                            }
                            if (s[p].bar) {
                                r[p].bar = r[p].bar.concat(s[p].bar);
                            }
                        }

                    }
                }
            };

            function Ext2() {}

            Ext2.prototype.extTwo = function() {};
            Ext2.prototype.methodTwo = function() {
                return "methodOne";
            };

            Ext2.CUST = {
                foo: [2, 3],
                bar: [2, 3, 4]
            };

            // ---

            var MyClass1 = Y.Base.create("myClass1", Y.Base, [Ext1]);
            var myclass1 = new MyClass1();

            Y.Assert.isTrue(myclass1 instanceof MyClass1);

            Y.Assert.isFunction(myclass1.methodOne);
            Y.Assert.isFunction(myclass1.init);

            // ObjectAssert.areEqual doesn't work: values don't == compare
            Y.ObjectAssert.hasKeys({
                bar:[1],
                foo:[1]
            }, MyClass1.CUST, "Class1 - object assert");

            Y.ArrayAssert.itemsAreEqual([1], MyClass1.CUST.foo, "Class1 foo assert");
            Y.ArrayAssert.itemsAreEqual([1], MyClass1.CUST.bar, "Class1 bar assert");

            Y.Assert.isFalse(MyClass1.CUST === Ext1.CUST, "Ext1.CUST shouldn't have been copied over");

            // ---

            var MyClass2 = Y.Base.create("myClass2", Y.Base, [Ext1, Ext2]);
            var myclass2 = new MyClass2();

            Y.Assert.isTrue(myclass2 instanceof MyClass2);

            Y.Assert.isFunction(myclass2.methodTwo); // prototype properties copied
            Y.Assert.isFunction(myclass2.init); // but prototype not switched completely by mistake

            // ObjectAssert.areEqual doesn't work: values don't == compare
            Y.ObjectAssert.hasKeys({
                foo:[1,2,3],
                bar:[1,2,3,4]
            }, MyClass2.CUST);

            Y.ArrayAssert.itemsAreEqual([1,2,3], MyClass2.CUST.foo);
            Y.ArrayAssert.itemsAreEqual([1,2,3,4], MyClass2.CUST.bar);

            Y.Assert.isFalse(MyClass2.CUST === Ext1.CUST, "Ext1.CUST shouldn't have been copied over");
            Y.Assert.isFalse(MyClass2.CUST === Ext2.CUST, "Ext2.CUST shouldn't have been copied over");
        }

    }));

    Y.Test.Runner.setName("Base Tests");
    Y.Test.Runner.add(suite);
    Y.Test.Runner.disableLogging();
    Y.Test.Runner.run();

    var console;

    Y.one("#btnRun").set("disabled", false).on("click", function() {
        if (!console) {
            console = new Y.Console({
                id:"console",
                width:"100%",
                height:"90%",
                verbose : false,
                printTimeout: 0,
                newestOnTop : false,
                entryTemplate: '<pre class="{entry_class} {cat_class} {src_class}">'+
                        '<span class="{entry_cat_class}">{label}</span>'+
                        '<span class="{entry_content_class}">{message}</span>'+
                '</pre>'
            }).render();
        }

        Y.Test.Runner.enableLogging();
        Y.Test.Runner.run();
    });
});
</script>
<p><input type="button" value="Run Tests" id="btnRun" disabled=true></p>
</body>
</html>