require.paths.push('/usr/local/lib/node_modules');

var path = require('path'),

YUI = require(path.join(__dirname, '../../../../', 'build/yui/yui.js')).YUI;

Y = YUI(),

YUITest = require("yuitest").YUITest,

Assert = YUITest.Assert,

ArrayAssert = YUITest.ArrayAssert,

suite = new YUITest.TestSuite("YUILoader");

var async = function(fn) {

var count = 0;

return function(data) {

var loaded = false;

var w = function() {

if (count === 1000) {

throw new Error('Async Timer reached 1000 iterations..');

}

count++;

if (!loaded) {

this.wait(w, 10);

}

};

var next = function() {

loaded = true;

};

fn.call(this, data, next);

this.wait(w, 10);

};

};

suite.add(new YUITest.TestCase({

name: "Loader Tests",

"Testing align-plugin": function(data) {

var loader = new Y.Loader({

require: ["align-plugin"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("align-plugin")) > -1, "Module (align-plugin) not found in sorted array");

},

"Testing anim": function(data) {

var loader = new Y.Loader({

require: ["anim"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("anim-base")) > -1, "Module (anim-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("anim-color")) > -1, "Module (anim-color) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("anim-curve")) > -1, "Module (anim-curve) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("anim-easing")) > -1, "Module (anim-easing) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("anim-node-plugin")) > -1, "Module (anim-node-plugin) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("anim-scroll")) > -1, "Module (anim-scroll) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("anim-xy")) > -1, "Module (anim-xy) not found in sorted array");

},

"Testing anim-base": function(data) {

var loader = new Y.Loader({

require: ["anim-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("anim-base")) > -1, "Module (anim-base) not found in sorted array");

},

"Testing anim-color": function(data) {

var loader = new Y.Loader({

require: ["anim-color"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("anim-color")) > -1, "Module (anim-color) not found in sorted array");

},

"Testing anim-curve": function(data) {

var loader = new Y.Loader({

require: ["anim-curve"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("anim-curve")) > -1, "Module (anim-curve) not found in sorted array");

},

"Testing anim-easing": function(data) {

var loader = new Y.Loader({

require: ["anim-easing"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("anim-easing")) > -1, "Module (anim-easing) not found in sorted array");

},

"Testing anim-node-plugin": function(data) {

var loader = new Y.Loader({

require: ["anim-node-plugin"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("anim-node-plugin")) > -1, "Module (anim-node-plugin) not found in sorted array");

},

"Testing anim-scroll": function(data) {

var loader = new Y.Loader({

require: ["anim-scroll"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("anim-scroll")) > -1, "Module (anim-scroll) not found in sorted array");

},

"Testing anim-xy": function(data) {

var loader = new Y.Loader({

require: ["anim-xy"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("anim-xy")) > -1, "Module (anim-xy) not found in sorted array");

},

"Testing app": function(data) {

var loader = new Y.Loader({

require: ["app"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("controller")) > -1, "Module (controller) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("model")) > -1, "Module (model) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("model-list")) > -1, "Module (model-list) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("view")) > -1, "Module (view) not found in sorted array");

},

"Testing array-extras": function(data) {

var loader = new Y.Loader({

require: ["array-extras"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("array-extras")) > -1, "Module (array-extras) not found in sorted array");

},

"Testing array-invoke": function(data) {

var loader = new Y.Loader({

require: ["array-invoke"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("array-invoke")) > -1, "Module (array-invoke) not found in sorted array");

},

"Testing arraylist": function(data) {

var loader = new Y.Loader({

require: ["arraylist"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("arraylist")) > -1, "Module (arraylist) not found in sorted array");

},

"Testing arraylist-add": function(data) {

var loader = new Y.Loader({

require: ["arraylist-add"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("arraylist-add")) > -1, "Module (arraylist-add) not found in sorted array");

},

"Testing arraylist-filter": function(data) {

var loader = new Y.Loader({

require: ["arraylist-filter"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("arraylist-filter")) > -1, "Module (arraylist-filter) not found in sorted array");

},

"Testing arraysort": function(data) {

var loader = new Y.Loader({

require: ["arraysort"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("arraysort")) > -1, "Module (arraysort) not found in sorted array");

},

"Testing async-queue": function(data) {

var loader = new Y.Loader({

require: ["async-queue"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("async-queue")) > -1, "Module (async-queue) not found in sorted array");

},

"Testing attribute": function(data) {

var loader = new Y.Loader({

require: ["attribute"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("attribute-base")) > -1, "Module (attribute-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("attribute-complex")) > -1, "Module (attribute-complex) not found in sorted array");

},

"Testing attribute-base": function(data) {

var loader = new Y.Loader({

require: ["attribute-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("attribute-base")) > -1, "Module (attribute-base) not found in sorted array");

},

"Testing attribute-complex": function(data) {

var loader = new Y.Loader({

require: ["attribute-complex"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("attribute-complex")) > -1, "Module (attribute-complex) not found in sorted array");

},

"Testing autocomplete": function(data) {

var loader = new Y.Loader({

require: ["autocomplete"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("autocomplete-base")) > -1, "Module (autocomplete-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("autocomplete-sources")) > -1, "Module (autocomplete-sources) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("autocomplete-list")) > -1, "Module (autocomplete-list) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("autocomplete-plugin")) > -1, "Module (autocomplete-plugin) not found in sorted array");

},

"Testing autocomplete-base": function(data) {

var loader = new Y.Loader({

require: ["autocomplete-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("autocomplete-base")) > -1, "Module (autocomplete-base) not found in sorted array");

},

"Testing autocomplete-filters": function(data) {

var loader = new Y.Loader({

require: ["autocomplete-filters"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("autocomplete-filters")) > -1, "Module (autocomplete-filters) not found in sorted array");

},

"Testing autocomplete-filters-accentfold": function(data) {

var loader = new Y.Loader({

require: ["autocomplete-filters-accentfold"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("autocomplete-filters-accentfold")) > -1, "Module (autocomplete-filters-accentfold) not found in sorted array");

},

"Testing autocomplete-highlighters": function(data) {

var loader = new Y.Loader({

require: ["autocomplete-highlighters"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("autocomplete-highlighters")) > -1, "Module (autocomplete-highlighters) not found in sorted array");

},

"Testing autocomplete-highlighters-accentfold": function(data) {

var loader = new Y.Loader({

require: ["autocomplete-highlighters-accentfold"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("autocomplete-highlighters-accentfold")) > -1, "Module (autocomplete-highlighters-accentfold) not found in sorted array");

},

"Testing autocomplete-list": function(data) {

var loader = new Y.Loader({

require: ["autocomplete-list"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("autocomplete-list")) > -1, "Module (autocomplete-list) not found in sorted array");

},

"Testing autocomplete-list-keys": function(data) {

var loader = new Y.Loader({

require: ["autocomplete-list-keys"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("autocomplete-list-keys")) > -1, "Module (autocomplete-list-keys) not found in sorted array");

},

"Testing autocomplete-plugin": function(data) {

var loader = new Y.Loader({

require: ["autocomplete-plugin"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("autocomplete-plugin")) > -1, "Module (autocomplete-plugin) not found in sorted array");

},

"Testing autocomplete-sources": function(data) {

var loader = new Y.Loader({

require: ["autocomplete-sources"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("autocomplete-sources")) > -1, "Module (autocomplete-sources) not found in sorted array");

},

"Testing base": function(data) {

var loader = new Y.Loader({

require: ["base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("base-base")) > -1, "Module (base-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("base-pluginhost")) > -1, "Module (base-pluginhost) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("base-build")) > -1, "Module (base-build) not found in sorted array");

},

"Testing base-base": function(data) {

var loader = new Y.Loader({

require: ["base-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("base-base")) > -1, "Module (base-base) not found in sorted array");

},

"Testing base-build": function(data) {

var loader = new Y.Loader({

require: ["base-build"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("base-build")) > -1, "Module (base-build) not found in sorted array");

},

"Testing base-pluginhost": function(data) {

var loader = new Y.Loader({

require: ["base-pluginhost"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("base-pluginhost")) > -1, "Module (base-pluginhost) not found in sorted array");

},

"Testing cache": function(data) {

var loader = new Y.Loader({

require: ["cache"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("cache-base")) > -1, "Module (cache-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("cache-offline")) > -1, "Module (cache-offline) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("cache-plugin")) > -1, "Module (cache-plugin) not found in sorted array");

},

"Testing cache-base": function(data) {

var loader = new Y.Loader({

require: ["cache-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("cache-base")) > -1, "Module (cache-base) not found in sorted array");

},

"Testing cache-offline": function(data) {

var loader = new Y.Loader({

require: ["cache-offline"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("cache-offline")) > -1, "Module (cache-offline) not found in sorted array");

},

"Testing cache-plugin": function(data) {

var loader = new Y.Loader({

require: ["cache-plugin"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("cache-plugin")) > -1, "Module (cache-plugin) not found in sorted array");

},

"Testing calendar": function(data) {

var loader = new Y.Loader({

require: ["calendar"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("calendar")) > -1, "Module (calendar) not found in sorted array");

},

"Testing calendar-base": function(data) {

var loader = new Y.Loader({

require: ["calendar-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("calendar-base")) > -1, "Module (calendar-base) not found in sorted array");

},

"Testing calendarnavigator": function(data) {

var loader = new Y.Loader({

require: ["calendarnavigator"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("calendarnavigator")) > -1, "Module (calendarnavigator) not found in sorted array");

},

"Testing charts": function(data) {

var loader = new Y.Loader({

require: ["charts"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("charts")) > -1, "Module (charts) not found in sorted array");

},

"Testing classnamemanager": function(data) {

var loader = new Y.Loader({

require: ["classnamemanager"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("classnamemanager")) > -1, "Module (classnamemanager) not found in sorted array");

},

"Testing clickable-rail": function(data) {

var loader = new Y.Loader({

require: ["clickable-rail"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("clickable-rail")) > -1, "Module (clickable-rail) not found in sorted array");

},

"Testing collection": function(data) {

var loader = new Y.Loader({

require: ["collection"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("array-extras")) > -1, "Module (array-extras) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("arraylist")) > -1, "Module (arraylist) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("arraylist-add")) > -1, "Module (arraylist-add) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("arraylist-filter")) > -1, "Module (arraylist-filter) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("array-invoke")) > -1, "Module (array-invoke) not found in sorted array");

},

"Testing console": function(data) {

var loader = new Y.Loader({

require: ["console"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("console")) > -1, "Module (console) not found in sorted array");

},

"Testing console-filters": function(data) {

var loader = new Y.Loader({

require: ["console-filters"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("console-filters")) > -1, "Module (console-filters) not found in sorted array");

},

"Testing controller": function(data) {

var loader = new Y.Loader({

require: ["controller"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("controller")) > -1, "Module (controller) not found in sorted array");

},

"Testing cookie": function(data) {

var loader = new Y.Loader({

require: ["cookie"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("cookie")) > -1, "Module (cookie) not found in sorted array");

},

"Testing createlink-base": function(data) {

var loader = new Y.Loader({

require: ["createlink-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("createlink-base")) > -1, "Module (createlink-base) not found in sorted array");

},

"Testing dataschema": function(data) {

var loader = new Y.Loader({

require: ["dataschema"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("dataschema-base")) > -1, "Module (dataschema-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("dataschema-json")) > -1, "Module (dataschema-json) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("dataschema-xml")) > -1, "Module (dataschema-xml) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("dataschema-array")) > -1, "Module (dataschema-array) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("dataschema-text")) > -1, "Module (dataschema-text) not found in sorted array");

},

"Testing dataschema-array": function(data) {

var loader = new Y.Loader({

require: ["dataschema-array"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dataschema-array")) > -1, "Module (dataschema-array) not found in sorted array");

},

"Testing dataschema-base": function(data) {

var loader = new Y.Loader({

require: ["dataschema-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dataschema-base")) > -1, "Module (dataschema-base) not found in sorted array");

},

"Testing dataschema-json": function(data) {

var loader = new Y.Loader({

require: ["dataschema-json"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dataschema-json")) > -1, "Module (dataschema-json) not found in sorted array");

},

"Testing dataschema-text": function(data) {

var loader = new Y.Loader({

require: ["dataschema-text"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dataschema-text")) > -1, "Module (dataschema-text) not found in sorted array");

},

"Testing dataschema-xml": function(data) {

var loader = new Y.Loader({

require: ["dataschema-xml"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dataschema-xml")) > -1, "Module (dataschema-xml) not found in sorted array");

},

"Testing datasource": function(data) {

var loader = new Y.Loader({

require: ["datasource"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("datasource-local")) > -1, "Module (datasource-local) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datasource-io")) > -1, "Module (datasource-io) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datasource-get")) > -1, "Module (datasource-get) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datasource-function")) > -1, "Module (datasource-function) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datasource-cache")) > -1, "Module (datasource-cache) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datasource-jsonschema")) > -1, "Module (datasource-jsonschema) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datasource-xmlschema")) > -1, "Module (datasource-xmlschema) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datasource-arrayschema")) > -1, "Module (datasource-arrayschema) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datasource-textschema")) > -1, "Module (datasource-textschema) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datasource-polling")) > -1, "Module (datasource-polling) not found in sorted array");

},

"Testing datasource-arrayschema": function(data) {

var loader = new Y.Loader({

require: ["datasource-arrayschema"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datasource-arrayschema")) > -1, "Module (datasource-arrayschema) not found in sorted array");

},

"Testing datasource-cache": function(data) {

var loader = new Y.Loader({

require: ["datasource-cache"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datasource-cache")) > -1, "Module (datasource-cache) not found in sorted array");

},

"Testing datasource-function": function(data) {

var loader = new Y.Loader({

require: ["datasource-function"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datasource-function")) > -1, "Module (datasource-function) not found in sorted array");

},

"Testing datasource-get": function(data) {

var loader = new Y.Loader({

require: ["datasource-get"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datasource-get")) > -1, "Module (datasource-get) not found in sorted array");

},

"Testing datasource-io": function(data) {

var loader = new Y.Loader({

require: ["datasource-io"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datasource-io")) > -1, "Module (datasource-io) not found in sorted array");

},

"Testing datasource-jsonschema": function(data) {

var loader = new Y.Loader({

require: ["datasource-jsonschema"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datasource-jsonschema")) > -1, "Module (datasource-jsonschema) not found in sorted array");

},

"Testing datasource-local": function(data) {

var loader = new Y.Loader({

require: ["datasource-local"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datasource-local")) > -1, "Module (datasource-local) not found in sorted array");

},

"Testing datasource-polling": function(data) {

var loader = new Y.Loader({

require: ["datasource-polling"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datasource-polling")) > -1, "Module (datasource-polling) not found in sorted array");

},

"Testing datasource-textschema": function(data) {

var loader = new Y.Loader({

require: ["datasource-textschema"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datasource-textschema")) > -1, "Module (datasource-textschema) not found in sorted array");

},

"Testing datasource-xmlschema": function(data) {

var loader = new Y.Loader({

require: ["datasource-xmlschema"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datasource-xmlschema")) > -1, "Module (datasource-xmlschema) not found in sorted array");

},

"Testing datatable": function(data) {

var loader = new Y.Loader({

require: ["datatable"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("datatable-base")) > -1, "Module (datatable-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datatable-datasource")) > -1, "Module (datatable-datasource) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datatable-sort")) > -1, "Module (datatable-sort) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datatable-scroll")) > -1, "Module (datatable-scroll) not found in sorted array");

},

"Testing datatable-base": function(data) {

var loader = new Y.Loader({

require: ["datatable-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datatable-base")) > -1, "Module (datatable-base) not found in sorted array");

},

"Testing datatable-datasource": function(data) {

var loader = new Y.Loader({

require: ["datatable-datasource"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datatable-datasource")) > -1, "Module (datatable-datasource) not found in sorted array");

},

"Testing datatable-scroll": function(data) {

var loader = new Y.Loader({

require: ["datatable-scroll"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datatable-scroll")) > -1, "Module (datatable-scroll) not found in sorted array");

},

"Testing datatable-sort": function(data) {

var loader = new Y.Loader({

require: ["datatable-sort"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datatable-sort")) > -1, "Module (datatable-sort) not found in sorted array");

},

"Testing datatype": function(data) {

var loader = new Y.Loader({

require: ["datatype"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

//Testing A rollup of a rollup module ( datatype )

Assert.isTrue((loader.sorted.indexOf("datatype-number-parse")) > -1, "Module (datatype-number-parse) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datatype-number-format")) > -1, "Module (datatype-number-format) not found in sorted array");

//Testing A rollup of a rollup module ( datatype )

Assert.isTrue((loader.sorted.indexOf("datatype-date-parse")) > -1, "Module (datatype-date-parse) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datatype-date-format")) > -1, "Module (datatype-date-format) not found in sorted array");

//Testing A rollup of a rollup module ( datatype )

Assert.isTrue((loader.sorted.indexOf("datatype-xml-parse")) > -1, "Module (datatype-xml-parse) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datatype-xml-format")) > -1, "Module (datatype-xml-format) not found in sorted array");

},

"Testing datatype-date": function(data) {

var loader = new Y.Loader({

require: ["datatype-date"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("datatype-date-parse")) > -1, "Module (datatype-date-parse) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datatype-date-format")) > -1, "Module (datatype-date-format) not found in sorted array");

},

"Testing datatype-date-format": function(data) {

var loader = new Y.Loader({

require: ["datatype-date-format"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datatype-date-format")) > -1, "Module (datatype-date-format) not found in sorted array");

},

"Testing datatype-date-math": function(data) {

var loader = new Y.Loader({

require: ["datatype-date-math"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datatype-date-math")) > -1, "Module (datatype-date-math) not found in sorted array");

},

"Testing datatype-date-parse": function(data) {

var loader = new Y.Loader({

require: ["datatype-date-parse"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datatype-date-parse")) > -1, "Module (datatype-date-parse) not found in sorted array");

},

"Testing datatype-number": function(data) {

var loader = new Y.Loader({

require: ["datatype-number"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("datatype-number-parse")) > -1, "Module (datatype-number-parse) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datatype-number-format")) > -1, "Module (datatype-number-format) not found in sorted array");

},

"Testing datatype-number-format": function(data) {

var loader = new Y.Loader({

require: ["datatype-number-format"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datatype-number-format")) > -1, "Module (datatype-number-format) not found in sorted array");

},

"Testing datatype-number-parse": function(data) {

var loader = new Y.Loader({

require: ["datatype-number-parse"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datatype-number-parse")) > -1, "Module (datatype-number-parse) not found in sorted array");

},

"Testing datatype-xml": function(data) {

var loader = new Y.Loader({

require: ["datatype-xml"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("datatype-xml-parse")) > -1, "Module (datatype-xml-parse) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("datatype-xml-format")) > -1, "Module (datatype-xml-format) not found in sorted array");

},

"Testing datatype-xml-format": function(data) {

var loader = new Y.Loader({

require: ["datatype-xml-format"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datatype-xml-format")) > -1, "Module (datatype-xml-format) not found in sorted array");

},

"Testing datatype-xml-parse": function(data) {

var loader = new Y.Loader({

require: ["datatype-xml-parse"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("datatype-xml-parse")) > -1, "Module (datatype-xml-parse) not found in sorted array");

},

"Testing dd": function(data) {

var loader = new Y.Loader({

require: ["dd"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("dd-ddm-base")) > -1, "Module (dd-ddm-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("dd-ddm")) > -1, "Module (dd-ddm) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("dd-ddm-drop")) > -1, "Module (dd-ddm-drop) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("dd-drag")) > -1, "Module (dd-drag) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("dd-proxy")) > -1, "Module (dd-proxy) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("dd-constrain")) > -1, "Module (dd-constrain) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("dd-drop")) > -1, "Module (dd-drop) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("dd-scroll")) > -1, "Module (dd-scroll) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("dd-delegate")) > -1, "Module (dd-delegate) not found in sorted array");

},

"Testing dd-constrain": function(data) {

var loader = new Y.Loader({

require: ["dd-constrain"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dd-constrain")) > -1, "Module (dd-constrain) not found in sorted array");

},

"Testing dd-ddm": function(data) {

var loader = new Y.Loader({

require: ["dd-ddm"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dd-ddm")) > -1, "Module (dd-ddm) not found in sorted array");

},

"Testing dd-ddm-base": function(data) {

var loader = new Y.Loader({

require: ["dd-ddm-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dd-ddm-base")) > -1, "Module (dd-ddm-base) not found in sorted array");

},

"Testing dd-ddm-drop": function(data) {

var loader = new Y.Loader({

require: ["dd-ddm-drop"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dd-ddm-drop")) > -1, "Module (dd-ddm-drop) not found in sorted array");

},

"Testing dd-delegate": function(data) {

var loader = new Y.Loader({

require: ["dd-delegate"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dd-delegate")) > -1, "Module (dd-delegate) not found in sorted array");

},

"Testing dd-drag": function(data) {

var loader = new Y.Loader({

require: ["dd-drag"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dd-drag")) > -1, "Module (dd-drag) not found in sorted array");

},

"Testing dd-drop": function(data) {

var loader = new Y.Loader({

require: ["dd-drop"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dd-drop")) > -1, "Module (dd-drop) not found in sorted array");

},

"Testing dd-drop-plugin": function(data) {

var loader = new Y.Loader({

require: ["dd-drop-plugin"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dd-drop-plugin")) > -1, "Module (dd-drop-plugin) not found in sorted array");

},

"Testing dd-gestures": function(data) {

var loader = new Y.Loader({

require: ["dd-gestures"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dd-gestures")) > -1, "Module (dd-gestures) not found in sorted array");

},

"Testing dd-plugin": function(data) {

var loader = new Y.Loader({

require: ["dd-plugin"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dd-plugin")) > -1, "Module (dd-plugin) not found in sorted array");

},

"Testing dd-proxy": function(data) {

var loader = new Y.Loader({

require: ["dd-proxy"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dd-proxy")) > -1, "Module (dd-proxy) not found in sorted array");

},

"Testing dd-scroll": function(data) {

var loader = new Y.Loader({

require: ["dd-scroll"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dd-scroll")) > -1, "Module (dd-scroll) not found in sorted array");

},

"Testing dial": function(data) {

var loader = new Y.Loader({

require: ["dial"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dial")) > -1, "Module (dial) not found in sorted array");

},

"Testing dom": function(data) {

var loader = new Y.Loader({

require: ["dom"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("dom-base")) > -1, "Module (dom-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("dom-screen")) > -1, "Module (dom-screen) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("dom-style")) > -1, "Module (dom-style) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("selector-native")) > -1, "Module (selector-native) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("selector")) > -1, "Module (selector) not found in sorted array");

},

"Testing dom-base": function(data) {

var loader = new Y.Loader({

require: ["dom-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dom-base")) > -1, "Module (dom-base) not found in sorted array");

},

"Testing dom-core": function(data) {

var loader = new Y.Loader({

require: ["dom-core"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dom-core")) > -1, "Module (dom-core) not found in sorted array");

},

"Testing dom-deprecated": function(data) {

var loader = new Y.Loader({

require: ["dom-deprecated"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dom-deprecated")) > -1, "Module (dom-deprecated) not found in sorted array");

},

"Testing dom-screen": function(data) {

var loader = new Y.Loader({

require: ["dom-screen"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dom-screen")) > -1, "Module (dom-screen) not found in sorted array");

},

"Testing dom-style": function(data) {

var loader = new Y.Loader({

require: ["dom-style"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dom-style")) > -1, "Module (dom-style) not found in sorted array");

},

"Testing dom-style-ie": function(data) {

var loader = new Y.Loader({

require: ["dom-style-ie"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dom-style-ie")) > -1, "Module (dom-style-ie) not found in sorted array");

},

"Testing dump": function(data) {

var loader = new Y.Loader({

require: ["dump"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("dump")) > -1, "Module (dump) not found in sorted array");

},

"Testing editor": function(data) {

var loader = new Y.Loader({

require: ["editor"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("frame")) > -1, "Module (frame) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("selection")) > -1, "Module (selection) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("exec-command")) > -1, "Module (exec-command) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("editor-base")) > -1, "Module (editor-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("editor-para")) > -1, "Module (editor-para) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("editor-br")) > -1, "Module (editor-br) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("editor-bidi")) > -1, "Module (editor-bidi) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("editor-tab")) > -1, "Module (editor-tab) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("createlink-base")) > -1, "Module (createlink-base) not found in sorted array");

},

"Testing editor-base": function(data) {

var loader = new Y.Loader({

require: ["editor-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("editor-base")) > -1, "Module (editor-base) not found in sorted array");

},

"Testing editor-bidi": function(data) {

var loader = new Y.Loader({

require: ["editor-bidi"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("editor-bidi")) > -1, "Module (editor-bidi) not found in sorted array");

},

"Testing editor-br": function(data) {

var loader = new Y.Loader({

require: ["editor-br"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("editor-br")) > -1, "Module (editor-br) not found in sorted array");

},

"Testing editor-lists": function(data) {

var loader = new Y.Loader({

require: ["editor-lists"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("editor-lists")) > -1, "Module (editor-lists) not found in sorted array");

},

"Testing editor-para": function(data) {

var loader = new Y.Loader({

require: ["editor-para"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("editor-para")) > -1, "Module (editor-para) not found in sorted array");

},

"Testing editor-tab": function(data) {

var loader = new Y.Loader({

require: ["editor-tab"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("editor-tab")) > -1, "Module (editor-tab) not found in sorted array");

},

"Testing escape": function(data) {

var loader = new Y.Loader({

require: ["escape"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("escape")) > -1, "Module (escape) not found in sorted array");

},

"Testing event": function(data) {

var loader = new Y.Loader({

require: ["event"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("event-base")) > -1, "Module (event-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("event-delegate")) > -1, "Module (event-delegate) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("event-synthetic")) > -1, "Module (event-synthetic) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("event-mousewheel")) > -1, "Module (event-mousewheel) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("event-mouseenter")) > -1, "Module (event-mouseenter) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("event-key")) > -1, "Module (event-key) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("event-focus")) > -1, "Module (event-focus) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("event-resize")) > -1, "Module (event-resize) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("event-hover")) > -1, "Module (event-hover) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("event-outside")) > -1, "Module (event-outside) not found in sorted array");

},

"Testing event-base": function(data) {

var loader = new Y.Loader({

require: ["event-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-base")) > -1, "Module (event-base) not found in sorted array");

},

"Testing event-base-ie": function(data) {

var loader = new Y.Loader({

require: ["event-base-ie"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-base-ie")) > -1, "Module (event-base-ie) not found in sorted array");

},

"Testing event-custom": function(data) {

var loader = new Y.Loader({

require: ["event-custom"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("event-custom-base")) > -1, "Module (event-custom-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("event-custom-complex")) > -1, "Module (event-custom-complex) not found in sorted array");

},

"Testing event-custom-base": function(data) {

var loader = new Y.Loader({

require: ["event-custom-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-custom-base")) > -1, "Module (event-custom-base) not found in sorted array");

},

"Testing event-custom-complex": function(data) {

var loader = new Y.Loader({

require: ["event-custom-complex"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-custom-complex")) > -1, "Module (event-custom-complex) not found in sorted array");

},

"Testing event-delegate": function(data) {

var loader = new Y.Loader({

require: ["event-delegate"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-delegate")) > -1, "Module (event-delegate) not found in sorted array");

},

"Testing event-flick": function(data) {

var loader = new Y.Loader({

require: ["event-flick"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-flick")) > -1, "Module (event-flick) not found in sorted array");

},

"Testing event-focus": function(data) {

var loader = new Y.Loader({

require: ["event-focus"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-focus")) > -1, "Module (event-focus) not found in sorted array");

},

"Testing event-gestures": function(data) {

var loader = new Y.Loader({

require: ["event-gestures"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("event-flick")) > -1, "Module (event-flick) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("event-move")) > -1, "Module (event-move) not found in sorted array");

},

"Testing event-hover": function(data) {

var loader = new Y.Loader({

require: ["event-hover"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-hover")) > -1, "Module (event-hover) not found in sorted array");

},

"Testing event-key": function(data) {

var loader = new Y.Loader({

require: ["event-key"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-key")) > -1, "Module (event-key) not found in sorted array");

},

"Testing event-mouseenter": function(data) {

var loader = new Y.Loader({

require: ["event-mouseenter"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-mouseenter")) > -1, "Module (event-mouseenter) not found in sorted array");

},

"Testing event-mousewheel": function(data) {

var loader = new Y.Loader({

require: ["event-mousewheel"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-mousewheel")) > -1, "Module (event-mousewheel) not found in sorted array");

},

"Testing event-move": function(data) {

var loader = new Y.Loader({

require: ["event-move"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-move")) > -1, "Module (event-move) not found in sorted array");

},

"Testing event-outside": function(data) {

var loader = new Y.Loader({

require: ["event-outside"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-outside")) > -1, "Module (event-outside) not found in sorted array");

},

"Testing event-resize": function(data) {

var loader = new Y.Loader({

require: ["event-resize"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-resize")) > -1, "Module (event-resize) not found in sorted array");

},

"Testing event-simulate": function(data) {

var loader = new Y.Loader({

require: ["event-simulate"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-simulate")) > -1, "Module (event-simulate) not found in sorted array");

},

"Testing event-synthetic": function(data) {

var loader = new Y.Loader({

require: ["event-synthetic"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-synthetic")) > -1, "Module (event-synthetic) not found in sorted array");

},

"Testing event-touch": function(data) {

var loader = new Y.Loader({

require: ["event-touch"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-touch")) > -1, "Module (event-touch) not found in sorted array");

},

"Testing event-valuechange": function(data) {

var loader = new Y.Loader({

require: ["event-valuechange"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("event-valuechange")) > -1, "Module (event-valuechange) not found in sorted array");

},

"Testing exec-command": function(data) {

var loader = new Y.Loader({

require: ["exec-command"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("exec-command")) > -1, "Module (exec-command) not found in sorted array");

},

"Testing frame": function(data) {

var loader = new Y.Loader({

require: ["frame"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("frame")) > -1, "Module (frame) not found in sorted array");

},

"Testing graphics": function(data) {

var loader = new Y.Loader({

require: ["graphics"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("graphics")) > -1, "Module (graphics) not found in sorted array");

},

"Testing graphics-canvas": function(data) {

var loader = new Y.Loader({

require: ["graphics-canvas"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("graphics-canvas")) > -1, "Module (graphics-canvas) not found in sorted array");

},

"Testing graphics-canvas-default": function(data) {

var loader = new Y.Loader({

require: ["graphics-canvas-default"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("graphics-canvas-default")) > -1, "Module (graphics-canvas-default) not found in sorted array");

},

"Testing graphics-svg": function(data) {

var loader = new Y.Loader({

require: ["graphics-svg"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("graphics-svg")) > -1, "Module (graphics-svg) not found in sorted array");

},

"Testing graphics-svg-default": function(data) {

var loader = new Y.Loader({

require: ["graphics-svg-default"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("graphics-svg-default")) > -1, "Module (graphics-svg-default) not found in sorted array");

},

"Testing graphics-vml": function(data) {

var loader = new Y.Loader({

require: ["graphics-vml"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("graphics-vml")) > -1, "Module (graphics-vml) not found in sorted array");

},

"Testing graphics-vml-default": function(data) {

var loader = new Y.Loader({

require: ["graphics-vml-default"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("graphics-vml-default")) > -1, "Module (graphics-vml-default) not found in sorted array");

},

"Testing highlight": function(data) {

var loader = new Y.Loader({

require: ["highlight"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("highlight-base")) > -1, "Module (highlight-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("highlight-accentfold")) > -1, "Module (highlight-accentfold) not found in sorted array");

},

"Testing highlight-accentfold": function(data) {

var loader = new Y.Loader({

require: ["highlight-accentfold"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("highlight-accentfold")) > -1, "Module (highlight-accentfold) not found in sorted array");

},

"Testing highlight-base": function(data) {

var loader = new Y.Loader({

require: ["highlight-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("highlight-base")) > -1, "Module (highlight-base) not found in sorted array");

},

"Testing history": function(data) {

var loader = new Y.Loader({

require: ["history"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("history-base")) > -1, "Module (history-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("history-hash")) > -1, "Module (history-hash) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("history-hash-ie")) > -1, "Module (history-hash-ie) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("history-html5")) > -1, "Module (history-html5) not found in sorted array");

},

"Testing history-base": function(data) {

var loader = new Y.Loader({

require: ["history-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("history-base")) > -1, "Module (history-base) not found in sorted array");

},

"Testing history-hash": function(data) {

var loader = new Y.Loader({

require: ["history-hash"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("history-hash")) > -1, "Module (history-hash) not found in sorted array");

},

"Testing history-hash-ie": function(data) {

var loader = new Y.Loader({

require: ["history-hash-ie"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("history-hash-ie")) > -1, "Module (history-hash-ie) not found in sorted array");

},

"Testing history-html5": function(data) {

var loader = new Y.Loader({

require: ["history-html5"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("history-html5")) > -1, "Module (history-html5) not found in sorted array");

},

"Testing imageloader": function(data) {

var loader = new Y.Loader({

require: ["imageloader"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("imageloader")) > -1, "Module (imageloader) not found in sorted array");

},

"Testing intl": function(data) {

var loader = new Y.Loader({

require: ["intl"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("intl")) > -1, "Module (intl) not found in sorted array");

},

"Testing io": function(data) {

var loader = new Y.Loader({

require: ["io"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("io-base")) > -1, "Module (io-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("io-xdr")) > -1, "Module (io-xdr) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("io-form")) > -1, "Module (io-form) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("io-upload-iframe")) > -1, "Module (io-upload-iframe) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("io-queue")) > -1, "Module (io-queue) not found in sorted array");

},

"Testing io-base": function(data) {

var loader = new Y.Loader({

require: ["io-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("io-base")) > -1, "Module (io-base) not found in sorted array");

},

"Testing io-form": function(data) {

var loader = new Y.Loader({

require: ["io-form"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("io-form")) > -1, "Module (io-form) not found in sorted array");

},

"Testing io-queue": function(data) {

var loader = new Y.Loader({

require: ["io-queue"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("io-queue")) > -1, "Module (io-queue) not found in sorted array");

},

"Testing io-upload-iframe": function(data) {

var loader = new Y.Loader({

require: ["io-upload-iframe"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("io-upload-iframe")) > -1, "Module (io-upload-iframe) not found in sorted array");

},

"Testing io-xdr": function(data) {

var loader = new Y.Loader({

require: ["io-xdr"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("io-xdr")) > -1, "Module (io-xdr) not found in sorted array");

},

"Testing json": function(data) {

var loader = new Y.Loader({

require: ["json"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("json-parse")) > -1, "Module (json-parse) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("json-stringify")) > -1, "Module (json-stringify) not found in sorted array");

},

"Testing json-parse": function(data) {

var loader = new Y.Loader({

require: ["json-parse"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("json-parse")) > -1, "Module (json-parse) not found in sorted array");

},

"Testing json-stringify": function(data) {

var loader = new Y.Loader({

require: ["json-stringify"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("json-stringify")) > -1, "Module (json-stringify) not found in sorted array");

},

"Testing jsonp": function(data) {

var loader = new Y.Loader({

require: ["jsonp"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("jsonp")) > -1, "Module (jsonp) not found in sorted array");

},

"Testing jsonp-url": function(data) {

var loader = new Y.Loader({

require: ["jsonp-url"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("jsonp-url")) > -1, "Module (jsonp-url) not found in sorted array");

},

"Testing model": function(data) {

var loader = new Y.Loader({

require: ["model"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("model")) > -1, "Module (model) not found in sorted array");

},

"Testing model-list": function(data) {

var loader = new Y.Loader({

require: ["model-list"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("model-list")) > -1, "Module (model-list) not found in sorted array");

},

"Testing node": function(data) {

var loader = new Y.Loader({

require: ["node"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("node-base")) > -1, "Module (node-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("node-event-delegate")) > -1, "Module (node-event-delegate) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("node-pluginhost")) > -1, "Module (node-pluginhost) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("node-screen")) > -1, "Module (node-screen) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("node-style")) > -1, "Module (node-style) not found in sorted array");

},

"Testing node-base": function(data) {

var loader = new Y.Loader({

require: ["node-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("node-base")) > -1, "Module (node-base) not found in sorted array");

},

"Testing node-core": function(data) {

var loader = new Y.Loader({

require: ["node-core"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("node-core")) > -1, "Module (node-core) not found in sorted array");

},

"Testing node-deprecated": function(data) {

var loader = new Y.Loader({

require: ["node-deprecated"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("node-deprecated")) > -1, "Module (node-deprecated) not found in sorted array");

},

"Testing node-event-delegate": function(data) {

var loader = new Y.Loader({

require: ["node-event-delegate"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("node-event-delegate")) > -1, "Module (node-event-delegate) not found in sorted array");

},

"Testing node-event-html5": function(data) {

var loader = new Y.Loader({

require: ["node-event-html5"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("node-event-html5")) > -1, "Module (node-event-html5) not found in sorted array");

},

"Testing node-event-simulate": function(data) {

var loader = new Y.Loader({

require: ["node-event-simulate"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("node-event-simulate")) > -1, "Module (node-event-simulate) not found in sorted array");

},

"Testing node-flick": function(data) {

var loader = new Y.Loader({

require: ["node-flick"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("node-flick")) > -1, "Module (node-flick) not found in sorted array");

},

"Testing node-focusmanager": function(data) {

var loader = new Y.Loader({

require: ["node-focusmanager"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("node-focusmanager")) > -1, "Module (node-focusmanager) not found in sorted array");

},

"Testing node-load": function(data) {

var loader = new Y.Loader({

require: ["node-load"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("node-load")) > -1, "Module (node-load) not found in sorted array");

},

"Testing node-menunav": function(data) {

var loader = new Y.Loader({

require: ["node-menunav"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("node-menunav")) > -1, "Module (node-menunav) not found in sorted array");

},

"Testing node-pluginhost": function(data) {

var loader = new Y.Loader({

require: ["node-pluginhost"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("node-pluginhost")) > -1, "Module (node-pluginhost) not found in sorted array");

},

"Testing node-screen": function(data) {

var loader = new Y.Loader({

require: ["node-screen"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("node-screen")) > -1, "Module (node-screen) not found in sorted array");

},

"Testing node-style": function(data) {

var loader = new Y.Loader({

require: ["node-style"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("node-style")) > -1, "Module (node-style) not found in sorted array");

},

"Testing oop": function(data) {

var loader = new Y.Loader({

require: ["oop"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("oop")) > -1, "Module (oop) not found in sorted array");

},

"Testing overlay": function(data) {

var loader = new Y.Loader({

require: ["overlay"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("overlay")) > -1, "Module (overlay) not found in sorted array");

},

"Testing panel": function(data) {

var loader = new Y.Loader({

require: ["panel"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("panel")) > -1, "Module (panel) not found in sorted array");

},

"Testing plugin": function(data) {

var loader = new Y.Loader({

require: ["plugin"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("plugin")) > -1, "Module (plugin) not found in sorted array");

},

"Testing pluginhost": function(data) {

var loader = new Y.Loader({

require: ["pluginhost"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("pluginhost-base")) > -1, "Module (pluginhost-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("pluginhost-config")) > -1, "Module (pluginhost-config) not found in sorted array");

},

"Testing pluginhost-base": function(data) {

var loader = new Y.Loader({

require: ["pluginhost-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("pluginhost-base")) > -1, "Module (pluginhost-base) not found in sorted array");

},

"Testing pluginhost-config": function(data) {

var loader = new Y.Loader({

require: ["pluginhost-config"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("pluginhost-config")) > -1, "Module (pluginhost-config) not found in sorted array");

},

"Testing profiler": function(data) {

var loader = new Y.Loader({

require: ["profiler"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("profiler")) > -1, "Module (profiler) not found in sorted array");

},

"Testing querystring": function(data) {

var loader = new Y.Loader({

require: ["querystring"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("querystring-parse")) > -1, "Module (querystring-parse) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("querystring-stringify")) > -1, "Module (querystring-stringify) not found in sorted array");

},

"Testing querystring-parse": function(data) {

var loader = new Y.Loader({

require: ["querystring-parse"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("querystring-parse")) > -1, "Module (querystring-parse) not found in sorted array");

},

"Testing querystring-parse-simple": function(data) {

var loader = new Y.Loader({

require: ["querystring-parse-simple"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("querystring-parse-simple")) > -1, "Module (querystring-parse-simple) not found in sorted array");

},

"Testing querystring-stringify": function(data) {

var loader = new Y.Loader({

require: ["querystring-stringify"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("querystring-stringify")) > -1, "Module (querystring-stringify) not found in sorted array");

},

"Testing querystring-stringify-simple": function(data) {

var loader = new Y.Loader({

require: ["querystring-stringify-simple"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("querystring-stringify-simple")) > -1, "Module (querystring-stringify-simple) not found in sorted array");

},

"Testing queue-promote": function(data) {

var loader = new Y.Loader({

require: ["queue-promote"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("queue-promote")) > -1, "Module (queue-promote) not found in sorted array");

},

"Testing range-slider": function(data) {

var loader = new Y.Loader({

require: ["range-slider"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("range-slider")) > -1, "Module (range-slider) not found in sorted array");

},

"Testing recordset": function(data) {

var loader = new Y.Loader({

require: ["recordset"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("recordset-base")) > -1, "Module (recordset-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("recordset-sort")) > -1, "Module (recordset-sort) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("recordset-filter")) > -1, "Module (recordset-filter) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("recordset-indexer")) > -1, "Module (recordset-indexer) not found in sorted array");

},

"Testing recordset-base": function(data) {

var loader = new Y.Loader({

require: ["recordset-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("recordset-base")) > -1, "Module (recordset-base) not found in sorted array");

},

"Testing recordset-filter": function(data) {

var loader = new Y.Loader({

require: ["recordset-filter"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("recordset-filter")) > -1, "Module (recordset-filter) not found in sorted array");

},

"Testing recordset-indexer": function(data) {

var loader = new Y.Loader({

require: ["recordset-indexer"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("recordset-indexer")) > -1, "Module (recordset-indexer) not found in sorted array");

},

"Testing recordset-sort": function(data) {

var loader = new Y.Loader({

require: ["recordset-sort"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("recordset-sort")) > -1, "Module (recordset-sort) not found in sorted array");

},

"Testing resize": function(data) {

var loader = new Y.Loader({

require: ["resize"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A rollup module

Assert.isTrue((loader.sorted.indexOf("resize-base")) > -1, "Module (resize-base) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("resize-proxy")) > -1, "Module (resize-proxy) not found in sorted array");

Assert.isTrue((loader.sorted.indexOf("resize-constrain")) > -1, "Module (resize-constrain) not found in sorted array");

},

"Testing resize-base": function(data) {

var loader = new Y.Loader({

require: ["resize-base"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("resize-base")) > -1, "Module (resize-base) not found in sorted array");

},

"Testing resize-constrain": function(data) {

var loader = new Y.Loader({

require: ["resize-constrain"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("resize-constrain")) > -1, "Module (resize-constrain) not found in sorted array");

},

"Testing resize-plugin": function(data) {

var loader = new Y.Loader({

require: ["resize-plugin"],

ignoreRegistered: true,

allowRollup: false

});

loader.calculate();

//Testing A normal module

Assert.isTrue((loader.sorted.indexOf("resize-plugin")) > -1, "Module (resize-plugin) not found in sorted array");

},

"Testing resize-proxy": function(data) {

var loader = new Y.Loader({