← Back to branch summary

~ubuntu-branches/ubuntu/raring/maas/raring-updates

« back to all changes in this revision

Viewing changes to src/maasserver/static/jslibs/yui/3.4.1/tests/loader/tests/cli/loader.js

  • Committer: Package Import Robot
  • Author(s): Andres Rodriguez
  • Date: 2012-07-03 17:42:37 UTC
  • mfrom: (1.1.13)
  • Revision ID: package-import@ubuntu.com-20120703174237-p8l0keuuznfg721k
Tags: 0.1+bzr709+dfsg-0ubuntu1
* New Upstream release
* debian/control:
  - Depends on python-celery, python-tempita, libjs-yui3-{full,min},
    libjs-raphael
* debian/maas.install:
  - Install apiclient, celeryconfig.py, maas-import-pxe-files, preseeds_v2.
  - Update to install various files from chroot, rather tha manually copy
    them from the source.
* debian/maas.links: symlink celeryconfig.py
* debian/maas.maas-celery.upstart: Add job.
* debian/rules:
  - Install celery upstart job.
  - Do not install jslibs as packages are now used.
  - Drop copying of maas_local_settings_sample.py as source now ships
    a maas_local_settings.py
* debian/patches:
  - 04-maas-http-fix.patch: Drop. Merged upstream.
  - 01-fix-database-settings.patch: Refreshed.
  - 99_enums_js.patch: Added until creation of enum.js / build process
    is fixed.
* debian/maas.postinst: Update bzr version to correctly handle upgrades.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/static/jslibs/yui/3.4.1/tests/loader/tests/cli/loader.js
1
 
/*
2
 
* This file was assembled by ../scripts/build_loader_tests.js
3
 
*/
4
 
 
5
 
//This is a hack for global modules in npm 1.0
6
 
require.paths.push('/usr/local/lib/node_modules');
7
 
 
8
 
var path = require('path'),
9
 
    YUI = require(path.join(__dirname, '../../../../', 'build/yui/yui.js')).YUI;
10
 
    Y = YUI(),
11
 
    YUITest = require("yuitest").YUITest,
12
 
    Assert = YUITest.Assert,
13
 
    ArrayAssert = YUITest.ArrayAssert,
14
 
    suite = new YUITest.TestSuite("YUILoader");
15
 
 
16
 
//Generic Async Wait
17
 
var async = function(fn) {
18
 
    var count = 0;
19
 
    return function(data) {
20
 
        var loaded = false;
21
 
        var w = function() {
22
 
            if (count === 1000) {
23
 
                throw new Error('Async Timer reached 1000 iterations..');
24
 
            }
25
 
            count++;
26
 
            if (!loaded) {
27
 
                this.wait(w, 10);
28
 
            }
29
 
        };
30
 
        var next = function() {
31
 
            loaded = true;
32
 
        };
33
 
        fn.call(this, data, next);
34
 
        this.wait(w, 10);
35
 
    };
36
 
};
37
 
 
38
 
/*
39
 
* !! TESTCASE !! will be replaced with a JSON object by the parent script.
40
 
*/
41
 
suite.add(new YUITest.TestCase({
42
 
    name: "Loader Tests",
43
 
         "Testing align-plugin": function(data) {
44
 
            var loader = new Y.Loader({
45
 
                require: ["align-plugin"],
46
 
                ignoreRegistered: true,
47
 
                allowRollup: false
48
 
            });
49
 
            loader.calculate();
50
 
            //Testing A normal module
51
 
            Assert.isTrue((loader.sorted.indexOf("align-plugin")) > -1, "Module (align-plugin) not found in sorted array");
52
 
        },
53
 
     "Testing anim": function(data) {
54
 
            var loader = new Y.Loader({
55
 
                require: ["anim"],
56
 
                ignoreRegistered: true,
57
 
                allowRollup: false
58
 
            });
59
 
            loader.calculate();
60
 
            //Testing A rollup module
61
 
            Assert.isTrue((loader.sorted.indexOf("anim-base")) > -1, "Module (anim-base) not found in sorted array");
62
 
            Assert.isTrue((loader.sorted.indexOf("anim-color")) > -1, "Module (anim-color) not found in sorted array");
63
 
            Assert.isTrue((loader.sorted.indexOf("anim-curve")) > -1, "Module (anim-curve) not found in sorted array");
64
 
            Assert.isTrue((loader.sorted.indexOf("anim-easing")) > -1, "Module (anim-easing) not found in sorted array");
65
 
            Assert.isTrue((loader.sorted.indexOf("anim-node-plugin")) > -1, "Module (anim-node-plugin) not found in sorted array");
66
 
            Assert.isTrue((loader.sorted.indexOf("anim-scroll")) > -1, "Module (anim-scroll) not found in sorted array");
67
 
            Assert.isTrue((loader.sorted.indexOf("anim-xy")) > -1, "Module (anim-xy) not found in sorted array");
68
 
        },
69
 
     "Testing anim-base": function(data) {
70
 
            var loader = new Y.Loader({
71
 
                require: ["anim-base"],
72
 
                ignoreRegistered: true,
73
 
                allowRollup: false
74
 
            });
75
 
            loader.calculate();
76
 
            //Testing A normal module
77
 
            Assert.isTrue((loader.sorted.indexOf("anim-base")) > -1, "Module (anim-base) not found in sorted array");
78
 
        },
79
 
     "Testing anim-color": function(data) {
80
 
            var loader = new Y.Loader({
81
 
                require: ["anim-color"],
82
 
                ignoreRegistered: true,
83
 
                allowRollup: false
84
 
            });
85
 
            loader.calculate();
86
 
            //Testing A normal module
87
 
            Assert.isTrue((loader.sorted.indexOf("anim-color")) > -1, "Module (anim-color) not found in sorted array");
88
 
        },
89
 
     "Testing anim-curve": function(data) {
90
 
            var loader = new Y.Loader({
91
 
                require: ["anim-curve"],
92
 
                ignoreRegistered: true,
93
 
                allowRollup: false
94
 
            });
95
 
            loader.calculate();
96
 
            //Testing A normal module
97
 
            Assert.isTrue((loader.sorted.indexOf("anim-curve")) > -1, "Module (anim-curve) not found in sorted array");
98
 
        },
99
 
     "Testing anim-easing": function(data) {
100
 
            var loader = new Y.Loader({
101
 
                require: ["anim-easing"],
102
 
                ignoreRegistered: true,
103
 
                allowRollup: false
104
 
            });
105
 
            loader.calculate();
106
 
            //Testing A normal module
107
 
            Assert.isTrue((loader.sorted.indexOf("anim-easing")) > -1, "Module (anim-easing) not found in sorted array");
108
 
        },
109
 
     "Testing anim-node-plugin": function(data) {
110
 
            var loader = new Y.Loader({
111
 
                require: ["anim-node-plugin"],
112
 
                ignoreRegistered: true,
113
 
                allowRollup: false
114
 
            });
115
 
            loader.calculate();
116
 
            //Testing A normal module
117
 
            Assert.isTrue((loader.sorted.indexOf("anim-node-plugin")) > -1, "Module (anim-node-plugin) not found in sorted array");
118
 
        },
119
 
     "Testing anim-scroll": function(data) {
120
 
            var loader = new Y.Loader({
121
 
                require: ["anim-scroll"],
122
 
                ignoreRegistered: true,
123
 
                allowRollup: false
124
 
            });
125
 
            loader.calculate();
126
 
            //Testing A normal module
127
 
            Assert.isTrue((loader.sorted.indexOf("anim-scroll")) > -1, "Module (anim-scroll) not found in sorted array");
128
 
        },
129
 
     "Testing anim-xy": function(data) {
130
 
            var loader = new Y.Loader({
131
 
                require: ["anim-xy"],
132
 
                ignoreRegistered: true,
133
 
                allowRollup: false
134
 
            });
135
 
            loader.calculate();
136
 
            //Testing A normal module
137
 
            Assert.isTrue((loader.sorted.indexOf("anim-xy")) > -1, "Module (anim-xy) not found in sorted array");
138
 
        },
139
 
     "Testing app": function(data) {
140
 
            var loader = new Y.Loader({
141
 
                require: ["app"],
142
 
                ignoreRegistered: true,
143
 
                allowRollup: false
144
 
            });
145
 
            loader.calculate();
146
 
            //Testing A rollup module
147
 
            Assert.isTrue((loader.sorted.indexOf("controller")) > -1, "Module (controller) not found in sorted array");
148
 
            Assert.isTrue((loader.sorted.indexOf("model")) > -1, "Module (model) not found in sorted array");
149
 
            Assert.isTrue((loader.sorted.indexOf("model-list")) > -1, "Module (model-list) not found in sorted array");
150
 
            Assert.isTrue((loader.sorted.indexOf("view")) > -1, "Module (view) not found in sorted array");
151
 
        },
152
 
     "Testing array-extras": function(data) {
153
 
            var loader = new Y.Loader({
154
 
                require: ["array-extras"],
155
 
                ignoreRegistered: true,
156
 
                allowRollup: false
157
 
            });
158
 
            loader.calculate();
159
 
            //Testing A normal module
160
 
            Assert.isTrue((loader.sorted.indexOf("array-extras")) > -1, "Module (array-extras) not found in sorted array");
161
 
        },
162
 
     "Testing array-invoke": function(data) {
163
 
            var loader = new Y.Loader({
164
 
                require: ["array-invoke"],
165
 
                ignoreRegistered: true,
166
 
                allowRollup: false
167
 
            });
168
 
            loader.calculate();
169
 
            //Testing A normal module
170
 
            Assert.isTrue((loader.sorted.indexOf("array-invoke")) > -1, "Module (array-invoke) not found in sorted array");
171
 
        },
172
 
     "Testing arraylist": function(data) {
173
 
            var loader = new Y.Loader({
174
 
                require: ["arraylist"],
175
 
                ignoreRegistered: true,
176
 
                allowRollup: false
177
 
            });
178
 
            loader.calculate();
179
 
            //Testing A normal module
180
 
            Assert.isTrue((loader.sorted.indexOf("arraylist")) > -1, "Module (arraylist) not found in sorted array");
181
 
        },
182
 
     "Testing arraylist-add": function(data) {
183
 
            var loader = new Y.Loader({
184
 
                require: ["arraylist-add"],
185
 
                ignoreRegistered: true,
186
 
                allowRollup: false
187
 
            });
188
 
            loader.calculate();
189
 
            //Testing A normal module
190
 
            Assert.isTrue((loader.sorted.indexOf("arraylist-add")) > -1, "Module (arraylist-add) not found in sorted array");
191
 
        },
192
 
     "Testing arraylist-filter": function(data) {
193
 
            var loader = new Y.Loader({
194
 
                require: ["arraylist-filter"],
195
 
                ignoreRegistered: true,
196
 
                allowRollup: false
197
 
            });
198
 
            loader.calculate();
199
 
            //Testing A normal module
200
 
            Assert.isTrue((loader.sorted.indexOf("arraylist-filter")) > -1, "Module (arraylist-filter) not found in sorted array");
201
 
        },
202
 
     "Testing arraysort": function(data) {
203
 
            var loader = new Y.Loader({
204
 
                require: ["arraysort"],
205
 
                ignoreRegistered: true,
206
 
                allowRollup: false
207
 
            });
208
 
            loader.calculate();
209
 
            //Testing A normal module
210
 
            Assert.isTrue((loader.sorted.indexOf("arraysort")) > -1, "Module (arraysort) not found in sorted array");
211
 
        },
212
 
     "Testing async-queue": function(data) {
213
 
            var loader = new Y.Loader({
214
 
                require: ["async-queue"],
215
 
                ignoreRegistered: true,
216
 
                allowRollup: false
217
 
            });
218
 
            loader.calculate();
219
 
            //Testing A normal module
220
 
            Assert.isTrue((loader.sorted.indexOf("async-queue")) > -1, "Module (async-queue) not found in sorted array");
221
 
        },
222
 
     "Testing attribute": function(data) {
223
 
            var loader = new Y.Loader({
224
 
                require: ["attribute"],
225
 
                ignoreRegistered: true,
226
 
                allowRollup: false
227
 
            });
228
 
            loader.calculate();
229
 
            //Testing A rollup module
230
 
            Assert.isTrue((loader.sorted.indexOf("attribute-base")) > -1, "Module (attribute-base) not found in sorted array");
231
 
            Assert.isTrue((loader.sorted.indexOf("attribute-complex")) > -1, "Module (attribute-complex) not found in sorted array");
232
 
        },
233
 
     "Testing attribute-base": function(data) {
234
 
            var loader = new Y.Loader({
235
 
                require: ["attribute-base"],
236
 
                ignoreRegistered: true,
237
 
                allowRollup: false
238
 
            });
239
 
            loader.calculate();
240
 
            //Testing A normal module
241
 
            Assert.isTrue((loader.sorted.indexOf("attribute-base")) > -1, "Module (attribute-base) not found in sorted array");
242
 
        },
243
 
     "Testing attribute-complex": function(data) {
244
 
            var loader = new Y.Loader({
245
 
                require: ["attribute-complex"],
246
 
                ignoreRegistered: true,
247
 
                allowRollup: false
248
 
            });
249
 
            loader.calculate();
250
 
            //Testing A normal module
251
 
            Assert.isTrue((loader.sorted.indexOf("attribute-complex")) > -1, "Module (attribute-complex) not found in sorted array");
252
 
        },
253
 
     "Testing autocomplete": function(data) {
254
 
            var loader = new Y.Loader({
255
 
                require: ["autocomplete"],
256
 
                ignoreRegistered: true,
257
 
                allowRollup: false
258
 
            });
259
 
            loader.calculate();
260
 
            //Testing A rollup module
261
 
            Assert.isTrue((loader.sorted.indexOf("autocomplete-base")) > -1, "Module (autocomplete-base) not found in sorted array");
262
 
            Assert.isTrue((loader.sorted.indexOf("autocomplete-sources")) > -1, "Module (autocomplete-sources) not found in sorted array");
263
 
            Assert.isTrue((loader.sorted.indexOf("autocomplete-list")) > -1, "Module (autocomplete-list) not found in sorted array");
264
 
            Assert.isTrue((loader.sorted.indexOf("autocomplete-plugin")) > -1, "Module (autocomplete-plugin) not found in sorted array");
265
 
        },
266
 
     "Testing autocomplete-base": function(data) {
267
 
            var loader = new Y.Loader({
268
 
                require: ["autocomplete-base"],
269
 
                ignoreRegistered: true,
270
 
                allowRollup: false
271
 
            });
272
 
            loader.calculate();
273
 
            //Testing A normal module
274
 
            Assert.isTrue((loader.sorted.indexOf("autocomplete-base")) > -1, "Module (autocomplete-base) not found in sorted array");
275
 
        },
276
 
     "Testing autocomplete-filters": function(data) {
277
 
            var loader = new Y.Loader({
278
 
                require: ["autocomplete-filters"],
279
 
                ignoreRegistered: true,
280
 
                allowRollup: false
281
 
            });
282
 
            loader.calculate();
283
 
            //Testing A normal module
284
 
            Assert.isTrue((loader.sorted.indexOf("autocomplete-filters")) > -1, "Module (autocomplete-filters) not found in sorted array");
285
 
        },
286
 
     "Testing autocomplete-filters-accentfold": function(data) {
287
 
            var loader = new Y.Loader({
288
 
                require: ["autocomplete-filters-accentfold"],
289
 
                ignoreRegistered: true,
290
 
                allowRollup: false
291
 
            });
292
 
            loader.calculate();
293
 
            //Testing A normal module
294
 
            Assert.isTrue((loader.sorted.indexOf("autocomplete-filters-accentfold")) > -1, "Module (autocomplete-filters-accentfold) not found in sorted array");
295
 
        },
296
 
     "Testing autocomplete-highlighters": function(data) {
297
 
            var loader = new Y.Loader({
298
 
                require: ["autocomplete-highlighters"],
299
 
                ignoreRegistered: true,
300
 
                allowRollup: false
301
 
            });
302
 
            loader.calculate();
303
 
            //Testing A normal module
304
 
            Assert.isTrue((loader.sorted.indexOf("autocomplete-highlighters")) > -1, "Module (autocomplete-highlighters) not found in sorted array");
305
 
        },
306
 
     "Testing autocomplete-highlighters-accentfold": function(data) {
307
 
            var loader = new Y.Loader({
308
 
                require: ["autocomplete-highlighters-accentfold"],
309
 
                ignoreRegistered: true,
310
 
                allowRollup: false
311
 
            });
312
 
            loader.calculate();
313
 
            //Testing A normal module
314
 
            Assert.isTrue((loader.sorted.indexOf("autocomplete-highlighters-accentfold")) > -1, "Module (autocomplete-highlighters-accentfold) not found in sorted array");
315
 
        },
316
 
     "Testing autocomplete-list": function(data) {
317
 
            var loader = new Y.Loader({
318
 
                require: ["autocomplete-list"],
319
 
                ignoreRegistered: true,
320
 
                allowRollup: false
321
 
            });
322
 
            loader.calculate();
323
 
            //Testing A normal module
324
 
            Assert.isTrue((loader.sorted.indexOf("autocomplete-list")) > -1, "Module (autocomplete-list) not found in sorted array");
325
 
        },
326
 
     "Testing autocomplete-list-keys": function(data) {
327
 
            var loader = new Y.Loader({
328
 
                require: ["autocomplete-list-keys"],
329
 
                ignoreRegistered: true,
330
 
                allowRollup: false
331
 
            });
332
 
            loader.calculate();
333
 
            //Testing A normal module
334
 
            Assert.isTrue((loader.sorted.indexOf("autocomplete-list-keys")) > -1, "Module (autocomplete-list-keys) not found in sorted array");
335
 
        },
336
 
     "Testing autocomplete-plugin": function(data) {
337
 
            var loader = new Y.Loader({
338
 
                require: ["autocomplete-plugin"],
339
 
                ignoreRegistered: true,
340
 
                allowRollup: false
341
 
            });
342
 
            loader.calculate();
343
 
            //Testing A normal module
344
 
            Assert.isTrue((loader.sorted.indexOf("autocomplete-plugin")) > -1, "Module (autocomplete-plugin) not found in sorted array");
345
 
        },
346
 
     "Testing autocomplete-sources": function(data) {
347
 
            var loader = new Y.Loader({
348
 
                require: ["autocomplete-sources"],
349
 
                ignoreRegistered: true,
350
 
                allowRollup: false
351
 
            });
352
 
            loader.calculate();
353
 
            //Testing A normal module
354
 
            Assert.isTrue((loader.sorted.indexOf("autocomplete-sources")) > -1, "Module (autocomplete-sources) not found in sorted array");
355
 
        },
356
 
     "Testing base": function(data) {
357
 
            var loader = new Y.Loader({
358
 
                require: ["base"],
359
 
                ignoreRegistered: true,
360
 
                allowRollup: false
361
 
            });
362
 
            loader.calculate();
363
 
            //Testing A rollup module
364
 
            Assert.isTrue((loader.sorted.indexOf("base-base")) > -1, "Module (base-base) not found in sorted array");
365
 
            Assert.isTrue((loader.sorted.indexOf("base-pluginhost")) > -1, "Module (base-pluginhost) not found in sorted array");
366
 
            Assert.isTrue((loader.sorted.indexOf("base-build")) > -1, "Module (base-build) not found in sorted array");
367
 
        },
368
 
     "Testing base-base": function(data) {
369
 
            var loader = new Y.Loader({
370
 
                require: ["base-base"],
371
 
                ignoreRegistered: true,
372
 
                allowRollup: false
373
 
            });
374
 
            loader.calculate();
375
 
            //Testing A normal module
376
 
            Assert.isTrue((loader.sorted.indexOf("base-base")) > -1, "Module (base-base) not found in sorted array");
377
 
        },
378
 
     "Testing base-build": function(data) {
379
 
            var loader = new Y.Loader({
380
 
                require: ["base-build"],
381
 
                ignoreRegistered: true,
382
 
                allowRollup: false
383
 
            });
384
 
            loader.calculate();
385
 
            //Testing A normal module
386
 
            Assert.isTrue((loader.sorted.indexOf("base-build")) > -1, "Module (base-build) not found in sorted array");
387
 
        },
388
 
     "Testing base-pluginhost": function(data) {
389
 
            var loader = new Y.Loader({
390
 
                require: ["base-pluginhost"],
391
 
                ignoreRegistered: true,
392
 
                allowRollup: false
393
 
            });
394
 
            loader.calculate();
395
 
            //Testing A normal module
396
 
            Assert.isTrue((loader.sorted.indexOf("base-pluginhost")) > -1, "Module (base-pluginhost) not found in sorted array");
397
 
        },
398
 
     "Testing cache": function(data) {
399
 
            var loader = new Y.Loader({
400
 
                require: ["cache"],
401
 
                ignoreRegistered: true,
402
 
                allowRollup: false
403
 
            });
404
 
            loader.calculate();
405
 
            //Testing A rollup module
406
 
            Assert.isTrue((loader.sorted.indexOf("cache-base")) > -1, "Module (cache-base) not found in sorted array");
407
 
            Assert.isTrue((loader.sorted.indexOf("cache-offline")) > -1, "Module (cache-offline) not found in sorted array");
408
 
            Assert.isTrue((loader.sorted.indexOf("cache-plugin")) > -1, "Module (cache-plugin) not found in sorted array");
409
 
        },
410
 
     "Testing cache-base": function(data) {
411
 
            var loader = new Y.Loader({
412
 
                require: ["cache-base"],
413
 
                ignoreRegistered: true,
414
 
                allowRollup: false
415
 
            });
416
 
            loader.calculate();
417
 
            //Testing A normal module
418
 
            Assert.isTrue((loader.sorted.indexOf("cache-base")) > -1, "Module (cache-base) not found in sorted array");
419
 
        },
420
 
     "Testing cache-offline": function(data) {
421
 
            var loader = new Y.Loader({
422
 
                require: ["cache-offline"],
423
 
                ignoreRegistered: true,
424
 
                allowRollup: false
425
 
            });
426
 
            loader.calculate();
427
 
            //Testing A normal module
428
 
            Assert.isTrue((loader.sorted.indexOf("cache-offline")) > -1, "Module (cache-offline) not found in sorted array");
429
 
        },
430
 
     "Testing cache-plugin": function(data) {
431
 
            var loader = new Y.Loader({
432
 
                require: ["cache-plugin"],
433
 
                ignoreRegistered: true,
434
 
                allowRollup: false
435
 
            });
436
 
            loader.calculate();
437
 
            //Testing A normal module
438
 
            Assert.isTrue((loader.sorted.indexOf("cache-plugin")) > -1, "Module (cache-plugin) not found in sorted array");
439
 
        },
440
 
     "Testing calendar": function(data) {
441
 
            var loader = new Y.Loader({
442
 
                require: ["calendar"],
443
 
                ignoreRegistered: true,
444
 
                allowRollup: false
445
 
            });
446
 
            loader.calculate();
447
 
            //Testing A normal module
448
 
            Assert.isTrue((loader.sorted.indexOf("calendar")) > -1, "Module (calendar) not found in sorted array");
449
 
        },
450
 
     "Testing calendar-base": function(data) {
451
 
            var loader = new Y.Loader({
452
 
                require: ["calendar-base"],
453
 
                ignoreRegistered: true,
454
 
                allowRollup: false
455
 
            });
456
 
            loader.calculate();
457
 
            //Testing A normal module
458
 
            Assert.isTrue((loader.sorted.indexOf("calendar-base")) > -1, "Module (calendar-base) not found in sorted array");
459
 
        },
460
 
     "Testing calendarnavigator": function(data) {
461
 
            var loader = new Y.Loader({
462
 
                require: ["calendarnavigator"],
463
 
                ignoreRegistered: true,
464
 
                allowRollup: false
465
 
            });
466
 
            loader.calculate();
467
 
            //Testing A normal module
468
 
            Assert.isTrue((loader.sorted.indexOf("calendarnavigator")) > -1, "Module (calendarnavigator) not found in sorted array");
469
 
        },
470
 
     "Testing charts": function(data) {
471
 
            var loader = new Y.Loader({
472
 
                require: ["charts"],
473
 
                ignoreRegistered: true,
474
 
                allowRollup: false
475
 
            });
476
 
            loader.calculate();
477
 
            //Testing A normal module
478
 
            Assert.isTrue((loader.sorted.indexOf("charts")) > -1, "Module (charts) not found in sorted array");
479
 
        },
480
 
     "Testing classnamemanager": function(data) {
481
 
            var loader = new Y.Loader({
482
 
                require: ["classnamemanager"],
483
 
                ignoreRegistered: true,
484
 
                allowRollup: false
485
 
            });
486
 
            loader.calculate();
487
 
            //Testing A normal module
488
 
            Assert.isTrue((loader.sorted.indexOf("classnamemanager")) > -1, "Module (classnamemanager) not found in sorted array");
489
 
        },
490
 
     "Testing clickable-rail": function(data) {
491
 
            var loader = new Y.Loader({
492
 
                require: ["clickable-rail"],
493
 
                ignoreRegistered: true,
494
 
                allowRollup: false
495
 
            });
496
 
            loader.calculate();
497
 
            //Testing A normal module
498
 
            Assert.isTrue((loader.sorted.indexOf("clickable-rail")) > -1, "Module (clickable-rail) not found in sorted array");
499
 
        },
500
 
     "Testing collection": function(data) {
501
 
            var loader = new Y.Loader({
502
 
                require: ["collection"],
503
 
                ignoreRegistered: true,
504
 
                allowRollup: false
505
 
            });
506
 
            loader.calculate();
507
 
            //Testing A rollup module
508
 
            Assert.isTrue((loader.sorted.indexOf("array-extras")) > -1, "Module (array-extras) not found in sorted array");
509
 
            Assert.isTrue((loader.sorted.indexOf("arraylist")) > -1, "Module (arraylist) not found in sorted array");
510
 
            Assert.isTrue((loader.sorted.indexOf("arraylist-add")) > -1, "Module (arraylist-add) not found in sorted array");
511
 
            Assert.isTrue((loader.sorted.indexOf("arraylist-filter")) > -1, "Module (arraylist-filter) not found in sorted array");
512
 
            Assert.isTrue((loader.sorted.indexOf("array-invoke")) > -1, "Module (array-invoke) not found in sorted array");
513
 
        },
514
 
     "Testing console": function(data) {
515
 
            var loader = new Y.Loader({
516
 
                require: ["console"],
517
 
                ignoreRegistered: true,
518
 
                allowRollup: false
519
 
            });
520
 
            loader.calculate();
521
 
            //Testing A normal module
522
 
            Assert.isTrue((loader.sorted.indexOf("console")) > -1, "Module (console) not found in sorted array");
523
 
        },
524
 
     "Testing console-filters": function(data) {
525
 
            var loader = new Y.Loader({
526
 
                require: ["console-filters"],
527
 
                ignoreRegistered: true,
528
 
                allowRollup: false
529
 
            });
530
 
            loader.calculate();
531
 
            //Testing A normal module
532
 
            Assert.isTrue((loader.sorted.indexOf("console-filters")) > -1, "Module (console-filters) not found in sorted array");
533
 
        },
534
 
     "Testing controller": function(data) {
535
 
            var loader = new Y.Loader({
536
 
                require: ["controller"],
537
 
                ignoreRegistered: true,
538
 
                allowRollup: false
539
 
            });
540
 
            loader.calculate();
541
 
            //Testing A normal module
542
 
            Assert.isTrue((loader.sorted.indexOf("controller")) > -1, "Module (controller) not found in sorted array");
543
 
        },
544
 
     "Testing cookie": function(data) {
545
 
            var loader = new Y.Loader({
546
 
                require: ["cookie"],
547
 
                ignoreRegistered: true,
548
 
                allowRollup: false
549
 
            });
550
 
            loader.calculate();
551
 
            //Testing A normal module
552
 
            Assert.isTrue((loader.sorted.indexOf("cookie")) > -1, "Module (cookie) not found in sorted array");
553
 
        },
554
 
     "Testing createlink-base": function(data) {
555
 
            var loader = new Y.Loader({
556
 
                require: ["createlink-base"],
557
 
                ignoreRegistered: true,
558
 
                allowRollup: false
559
 
            });
560
 
            loader.calculate();
561
 
            //Testing A normal module
562
 
            Assert.isTrue((loader.sorted.indexOf("createlink-base")) > -1, "Module (createlink-base) not found in sorted array");
563
 
        },
564
 
     "Testing dataschema": function(data) {
565
 
            var loader = new Y.Loader({
566
 
                require: ["dataschema"],
567
 
                ignoreRegistered: true,
568
 
                allowRollup: false
569
 
            });
570
 
            loader.calculate();
571
 
            //Testing A rollup module
572
 
            Assert.isTrue((loader.sorted.indexOf("dataschema-base")) > -1, "Module (dataschema-base) not found in sorted array");
573
 
            Assert.isTrue((loader.sorted.indexOf("dataschema-json")) > -1, "Module (dataschema-json) not found in sorted array");
574
 
            Assert.isTrue((loader.sorted.indexOf("dataschema-xml")) > -1, "Module (dataschema-xml) not found in sorted array");
575
 
            Assert.isTrue((loader.sorted.indexOf("dataschema-array")) > -1, "Module (dataschema-array) not found in sorted array");
576
 
            Assert.isTrue((loader.sorted.indexOf("dataschema-text")) > -1, "Module (dataschema-text) not found in sorted array");
577
 
        },
578
 
     "Testing dataschema-array": function(data) {
579
 
            var loader = new Y.Loader({
580
 
                require: ["dataschema-array"],
581
 
                ignoreRegistered: true,
582
 
                allowRollup: false
583
 
            });
584
 
            loader.calculate();
585
 
            //Testing A normal module
586
 
            Assert.isTrue((loader.sorted.indexOf("dataschema-array")) > -1, "Module (dataschema-array) not found in sorted array");
587
 
        },
588
 
     "Testing dataschema-base": function(data) {
589
 
            var loader = new Y.Loader({
590
 
                require: ["dataschema-base"],
591
 
                ignoreRegistered: true,
592
 
                allowRollup: false
593
 
            });
594
 
            loader.calculate();
595
 
            //Testing A normal module
596
 
            Assert.isTrue((loader.sorted.indexOf("dataschema-base")) > -1, "Module (dataschema-base) not found in sorted array");
597
 
        },
598
 
     "Testing dataschema-json": function(data) {
599
 
            var loader = new Y.Loader({
600
 
                require: ["dataschema-json"],
601
 
                ignoreRegistered: true,
602
 
                allowRollup: false
603
 
            });
604
 
            loader.calculate();
605
 
            //Testing A normal module
606
 
            Assert.isTrue((loader.sorted.indexOf("dataschema-json")) > -1, "Module (dataschema-json) not found in sorted array");
607
 
        },
608
 
     "Testing dataschema-text": function(data) {
609
 
            var loader = new Y.Loader({
610
 
                require: ["dataschema-text"],
611
 
                ignoreRegistered: true,
612
 
                allowRollup: false
613
 
            });
614
 
            loader.calculate();
615
 
            //Testing A normal module
616
 
            Assert.isTrue((loader.sorted.indexOf("dataschema-text")) > -1, "Module (dataschema-text) not found in sorted array");
617
 
        },
618
 
     "Testing dataschema-xml": function(data) {
619
 
            var loader = new Y.Loader({
620
 
                require: ["dataschema-xml"],
621
 
                ignoreRegistered: true,
622
 
                allowRollup: false
623
 
            });
624
 
            loader.calculate();
625
 
            //Testing A normal module
626
 
            Assert.isTrue((loader.sorted.indexOf("dataschema-xml")) > -1, "Module (dataschema-xml) not found in sorted array");
627
 
        },
628
 
     "Testing datasource": function(data) {
629
 
            var loader = new Y.Loader({
630
 
                require: ["datasource"],
631
 
                ignoreRegistered: true,
632
 
                allowRollup: false
633
 
            });
634
 
            loader.calculate();
635
 
            //Testing A rollup module
636
 
            Assert.isTrue((loader.sorted.indexOf("datasource-local")) > -1, "Module (datasource-local) not found in sorted array");
637
 
            Assert.isTrue((loader.sorted.indexOf("datasource-io")) > -1, "Module (datasource-io) not found in sorted array");
638
 
            Assert.isTrue((loader.sorted.indexOf("datasource-get")) > -1, "Module (datasource-get) not found in sorted array");
639
 
            Assert.isTrue((loader.sorted.indexOf("datasource-function")) > -1, "Module (datasource-function) not found in sorted array");
640
 
            Assert.isTrue((loader.sorted.indexOf("datasource-cache")) > -1, "Module (datasource-cache) not found in sorted array");
641
 
            Assert.isTrue((loader.sorted.indexOf("datasource-jsonschema")) > -1, "Module (datasource-jsonschema) not found in sorted array");
642
 
            Assert.isTrue((loader.sorted.indexOf("datasource-xmlschema")) > -1, "Module (datasource-xmlschema) not found in sorted array");
643
 
            Assert.isTrue((loader.sorted.indexOf("datasource-arrayschema")) > -1, "Module (datasource-arrayschema) not found in sorted array");
644
 
            Assert.isTrue((loader.sorted.indexOf("datasource-textschema")) > -1, "Module (datasource-textschema) not found in sorted array");
645
 
            Assert.isTrue((loader.sorted.indexOf("datasource-polling")) > -1, "Module (datasource-polling) not found in sorted array");
646
 
        },
647
 
     "Testing datasource-arrayschema": function(data) {
648
 
            var loader = new Y.Loader({
649
 
                require: ["datasource-arrayschema"],
650
 
                ignoreRegistered: true,
651
 
                allowRollup: false
652
 
            });
653
 
            loader.calculate();
654
 
            //Testing A normal module
655
 
            Assert.isTrue((loader.sorted.indexOf("datasource-arrayschema")) > -1, "Module (datasource-arrayschema) not found in sorted array");
656
 
        },
657
 
     "Testing datasource-cache": function(data) {
658
 
            var loader = new Y.Loader({
659
 
                require: ["datasource-cache"],
660
 
                ignoreRegistered: true,
661
 
                allowRollup: false
662
 
            });
663
 
            loader.calculate();
664
 
            //Testing A normal module
665
 
            Assert.isTrue((loader.sorted.indexOf("datasource-cache")) > -1, "Module (datasource-cache) not found in sorted array");
666
 
        },
667
 
     "Testing datasource-function": function(data) {
668
 
            var loader = new Y.Loader({
669
 
                require: ["datasource-function"],
670
 
                ignoreRegistered: true,
671
 
                allowRollup: false
672
 
            });
673
 
            loader.calculate();
674
 
            //Testing A normal module
675
 
            Assert.isTrue((loader.sorted.indexOf("datasource-function")) > -1, "Module (datasource-function) not found in sorted array");
676
 
        },
677
 
     "Testing datasource-get": function(data) {
678
 
            var loader = new Y.Loader({
679
 
                require: ["datasource-get"],
680
 
                ignoreRegistered: true,
681
 
                allowRollup: false
682
 
            });
683
 
            loader.calculate();
684
 
            //Testing A normal module
685
 
            Assert.isTrue((loader.sorted.indexOf("datasource-get")) > -1, "Module (datasource-get) not found in sorted array");
686
 
        },
687
 
     "Testing datasource-io": function(data) {
688
 
            var loader = new Y.Loader({
689
 
                require: ["datasource-io"],
690
 
                ignoreRegistered: true,
691
 
                allowRollup: false
692
 
            });
693
 
            loader.calculate();
694
 
            //Testing A normal module
695
 
            Assert.isTrue((loader.sorted.indexOf("datasource-io")) > -1, "Module (datasource-io) not found in sorted array");
696
 
        },
697
 
     "Testing datasource-jsonschema": function(data) {
698
 
            var loader = new Y.Loader({
699
 
                require: ["datasource-jsonschema"],
700
 
                ignoreRegistered: true,
701
 
                allowRollup: false
702
 
            });
703
 
            loader.calculate();
704
 
            //Testing A normal module
705
 
            Assert.isTrue((loader.sorted.indexOf("datasource-jsonschema")) > -1, "Module (datasource-jsonschema) not found in sorted array");
706
 
        },
707
 
     "Testing datasource-local": function(data) {
708
 
            var loader = new Y.Loader({
709
 
                require: ["datasource-local"],
710
 
                ignoreRegistered: true,
711
 
                allowRollup: false
712
 
            });
713
 
            loader.calculate();
714
 
            //Testing A normal module
715
 
            Assert.isTrue((loader.sorted.indexOf("datasource-local")) > -1, "Module (datasource-local) not found in sorted array");
716
 
        },
717
 
     "Testing datasource-polling": function(data) {
718
 
            var loader = new Y.Loader({
719
 
                require: ["datasource-polling"],
720
 
                ignoreRegistered: true,
721
 
                allowRollup: false
722
 
            });
723
 
            loader.calculate();
724
 
            //Testing A normal module
725
 
            Assert.isTrue((loader.sorted.indexOf("datasource-polling")) > -1, "Module (datasource-polling) not found in sorted array");
726
 
        },
727
 
     "Testing datasource-textschema": function(data) {
728
 
            var loader = new Y.Loader({
729
 
                require: ["datasource-textschema"],
730
 
                ignoreRegistered: true,
731
 
                allowRollup: false
732
 
            });
733
 
            loader.calculate();
734
 
            //Testing A normal module
735
 
            Assert.isTrue((loader.sorted.indexOf("datasource-textschema")) > -1, "Module (datasource-textschema) not found in sorted array");
736
 
        },
737
 
     "Testing datasource-xmlschema": function(data) {
738
 
            var loader = new Y.Loader({
739
 
                require: ["datasource-xmlschema"],
740
 
                ignoreRegistered: true,
741
 
                allowRollup: false
742
 
            });
743
 
            loader.calculate();
744
 
            //Testing A normal module
745
 
            Assert.isTrue((loader.sorted.indexOf("datasource-xmlschema")) > -1, "Module (datasource-xmlschema) not found in sorted array");
746
 
        },
747
 
     "Testing datatable": function(data) {
748
 
            var loader = new Y.Loader({
749
 
                require: ["datatable"],
750
 
                ignoreRegistered: true,
751
 
                allowRollup: false
752
 
            });
753
 
            loader.calculate();
754
 
            //Testing A rollup module
755
 
            Assert.isTrue((loader.sorted.indexOf("datatable-base")) > -1, "Module (datatable-base) not found in sorted array");
756
 
            Assert.isTrue((loader.sorted.indexOf("datatable-datasource")) > -1, "Module (datatable-datasource) not found in sorted array");
757
 
            Assert.isTrue((loader.sorted.indexOf("datatable-sort")) > -1, "Module (datatable-sort) not found in sorted array");
758
 
            Assert.isTrue((loader.sorted.indexOf("datatable-scroll")) > -1, "Module (datatable-scroll) not found in sorted array");
759
 
        },
760
 
     "Testing datatable-base": function(data) {
761
 
            var loader = new Y.Loader({
762
 
                require: ["datatable-base"],
763
 
                ignoreRegistered: true,
764
 
                allowRollup: false
765
 
            });
766
 
            loader.calculate();
767
 
            //Testing A normal module
768
 
            Assert.isTrue((loader.sorted.indexOf("datatable-base")) > -1, "Module (datatable-base) not found in sorted array");
769
 
        },
770
 
     "Testing datatable-datasource": function(data) {
771
 
            var loader = new Y.Loader({
772
 
                require: ["datatable-datasource"],
773
 
                ignoreRegistered: true,
774
 
                allowRollup: false
775
 
            });
776
 
            loader.calculate();
777
 
            //Testing A normal module
778
 
            Assert.isTrue((loader.sorted.indexOf("datatable-datasource")) > -1, "Module (datatable-datasource) not found in sorted array");
779
 
        },
780
 
     "Testing datatable-scroll": function(data) {
781
 
            var loader = new Y.Loader({
782
 
                require: ["datatable-scroll"],
783
 
                ignoreRegistered: true,
784
 
                allowRollup: false
785
 
            });
786
 
            loader.calculate();
787
 
            //Testing A normal module
788
 
            Assert.isTrue((loader.sorted.indexOf("datatable-scroll")) > -1, "Module (datatable-scroll) not found in sorted array");
789
 
        },
790
 
     "Testing datatable-sort": function(data) {
791
 
            var loader = new Y.Loader({
792
 
                require: ["datatable-sort"],
793
 
                ignoreRegistered: true,
794
 
                allowRollup: false
795
 
            });
796
 
            loader.calculate();
797
 
            //Testing A normal module
798
 
            Assert.isTrue((loader.sorted.indexOf("datatable-sort")) > -1, "Module (datatable-sort) not found in sorted array");
799
 
        },
800
 
     "Testing datatype": function(data) {
801
 
            var loader = new Y.Loader({
802
 
                require: ["datatype"],
803
 
                ignoreRegistered: true,
804
 
                allowRollup: false
805
 
            });
806
 
            loader.calculate();
807
 
            //Testing A rollup module
808
 
            //Testing A rollup of a rollup module ( datatype )
809
 
            Assert.isTrue((loader.sorted.indexOf("datatype-number-parse")) > -1, "Module (datatype-number-parse) not found in sorted array");
810
 
            Assert.isTrue((loader.sorted.indexOf("datatype-number-format")) > -1, "Module (datatype-number-format) not found in sorted array");
811
 
            //Testing A rollup of a rollup module ( datatype )
812
 
            Assert.isTrue((loader.sorted.indexOf("datatype-date-parse")) > -1, "Module (datatype-date-parse) not found in sorted array");
813
 
            Assert.isTrue((loader.sorted.indexOf("datatype-date-format")) > -1, "Module (datatype-date-format) not found in sorted array");
814
 
            //Testing A rollup of a rollup module ( datatype )
815
 
            Assert.isTrue((loader.sorted.indexOf("datatype-xml-parse")) > -1, "Module (datatype-xml-parse) not found in sorted array");
816
 
            Assert.isTrue((loader.sorted.indexOf("datatype-xml-format")) > -1, "Module (datatype-xml-format) not found in sorted array");
817
 
        },
818
 
     "Testing datatype-date": function(data) {
819
 
            var loader = new Y.Loader({
820
 
                require: ["datatype-date"],
821
 
                ignoreRegistered: true,
822
 
                allowRollup: false
823
 
            });
824
 
            loader.calculate();
825
 
            //Testing A rollup module
826
 
            Assert.isTrue((loader.sorted.indexOf("datatype-date-parse")) > -1, "Module (datatype-date-parse) not found in sorted array");
827
 
            Assert.isTrue((loader.sorted.indexOf("datatype-date-format")) > -1, "Module (datatype-date-format) not found in sorted array");
828
 
        },
829
 
     "Testing datatype-date-format": function(data) {
830
 
            var loader = new Y.Loader({
831
 
                require: ["datatype-date-format"],
832
 
                ignoreRegistered: true,
833
 
                allowRollup: false
834
 
            });
835
 
            loader.calculate();
836
 
            //Testing A normal module
837
 
            Assert.isTrue((loader.sorted.indexOf("datatype-date-format")) > -1, "Module (datatype-date-format) not found in sorted array");
838
 
        },
839
 
     "Testing datatype-date-math": function(data) {
840
 
            var loader = new Y.Loader({
841
 
                require: ["datatype-date-math"],
842
 
                ignoreRegistered: true,
843
 
                allowRollup: false
844
 
            });
845
 
            loader.calculate();
846
 
            //Testing A normal module
847
 
            Assert.isTrue((loader.sorted.indexOf("datatype-date-math")) > -1, "Module (datatype-date-math) not found in sorted array");
848
 
        },
849
 
     "Testing datatype-date-parse": function(data) {
850
 
            var loader = new Y.Loader({
851
 
                require: ["datatype-date-parse"],
852
 
                ignoreRegistered: true,
853
 
                allowRollup: false
854
 
            });
855
 
            loader.calculate();
856
 
            //Testing A normal module
857
 
            Assert.isTrue((loader.sorted.indexOf("datatype-date-parse")) > -1, "Module (datatype-date-parse) not found in sorted array");
858
 
        },
859
 
     "Testing datatype-number": function(data) {
860
 
            var loader = new Y.Loader({
861
 
                require: ["datatype-number"],
862
 
                ignoreRegistered: true,
863
 
                allowRollup: false
864
 
            });
865
 
            loader.calculate();
866
 
            //Testing A rollup module
867
 
            Assert.isTrue((loader.sorted.indexOf("datatype-number-parse")) > -1, "Module (datatype-number-parse) not found in sorted array");
868
 
            Assert.isTrue((loader.sorted.indexOf("datatype-number-format")) > -1, "Module (datatype-number-format) not found in sorted array");
869
 
        },
870
 
     "Testing datatype-number-format": function(data) {
871
 
            var loader = new Y.Loader({
872
 
                require: ["datatype-number-format"],
873
 
                ignoreRegistered: true,
874
 
                allowRollup: false
875
 
            });
876
 
            loader.calculate();
877
 
            //Testing A normal module
878
 
            Assert.isTrue((loader.sorted.indexOf("datatype-number-format")) > -1, "Module (datatype-number-format) not found in sorted array");
879
 
        },
880
 
     "Testing datatype-number-parse": function(data) {
881
 
            var loader = new Y.Loader({
882
 
                require: ["datatype-number-parse"],
883
 
                ignoreRegistered: true,
884
 
                allowRollup: false
885
 
            });
886
 
            loader.calculate();
887
 
            //Testing A normal module
888
 
            Assert.isTrue((loader.sorted.indexOf("datatype-number-parse")) > -1, "Module (datatype-number-parse) not found in sorted array");
889
 
        },
890
 
     "Testing datatype-xml": function(data) {
891
 
            var loader = new Y.Loader({
892
 
                require: ["datatype-xml"],
893
 
                ignoreRegistered: true,
894
 
                allowRollup: false
895
 
            });
896
 
            loader.calculate();
897
 
            //Testing A rollup module
898
 
            Assert.isTrue((loader.sorted.indexOf("datatype-xml-parse")) > -1, "Module (datatype-xml-parse) not found in sorted array");
899
 
            Assert.isTrue((loader.sorted.indexOf("datatype-xml-format")) > -1, "Module (datatype-xml-format) not found in sorted array");
900
 
        },
901
 
     "Testing datatype-xml-format": function(data) {
902
 
            var loader = new Y.Loader({
903
 
                require: ["datatype-xml-format"],
904
 
                ignoreRegistered: true,
905
 
                allowRollup: false
906
 
            });
907
 
            loader.calculate();
908
 
            //Testing A normal module
909
 
            Assert.isTrue((loader.sorted.indexOf("datatype-xml-format")) > -1, "Module (datatype-xml-format) not found in sorted array");
910
 
        },
911
 
     "Testing datatype-xml-parse": function(data) {
912
 
            var loader = new Y.Loader({
913
 
                require: ["datatype-xml-parse"],
914
 
                ignoreRegistered: true,
915
 
                allowRollup: false
916
 
            });
917
 
            loader.calculate();
918
 
            //Testing A normal module
919
 
            Assert.isTrue((loader.sorted.indexOf("datatype-xml-parse")) > -1, "Module (datatype-xml-parse) not found in sorted array");
920
 
        },
921
 
     "Testing dd": function(data) {
922
 
            var loader = new Y.Loader({
923
 
                require: ["dd"],
924
 
                ignoreRegistered: true,
925
 
                allowRollup: false
926
 
            });
927
 
            loader.calculate();
928
 
            //Testing A rollup module
929
 
            Assert.isTrue((loader.sorted.indexOf("dd-ddm-base")) > -1, "Module (dd-ddm-base) not found in sorted array");
930
 
            Assert.isTrue((loader.sorted.indexOf("dd-ddm")) > -1, "Module (dd-ddm) not found in sorted array");
931
 
            Assert.isTrue((loader.sorted.indexOf("dd-ddm-drop")) > -1, "Module (dd-ddm-drop) not found in sorted array");
932
 
            Assert.isTrue((loader.sorted.indexOf("dd-drag")) > -1, "Module (dd-drag) not found in sorted array");
933
 
            Assert.isTrue((loader.sorted.indexOf("dd-proxy")) > -1, "Module (dd-proxy) not found in sorted array");
934
 
            Assert.isTrue((loader.sorted.indexOf("dd-constrain")) > -1, "Module (dd-constrain) not found in sorted array");
935
 
            Assert.isTrue((loader.sorted.indexOf("dd-drop")) > -1, "Module (dd-drop) not found in sorted array");
936
 
            Assert.isTrue((loader.sorted.indexOf("dd-scroll")) > -1, "Module (dd-scroll) not found in sorted array");
937
 
            Assert.isTrue((loader.sorted.indexOf("dd-delegate")) > -1, "Module (dd-delegate) not found in sorted array");
938
 
        },
939
 
     "Testing dd-constrain": function(data) {
940
 
            var loader = new Y.Loader({
941
 
                require: ["dd-constrain"],
942
 
                ignoreRegistered: true,
943
 
                allowRollup: false
944
 
            });
945
 
            loader.calculate();
946
 
            //Testing A normal module
947
 
            Assert.isTrue((loader.sorted.indexOf("dd-constrain")) > -1, "Module (dd-constrain) not found in sorted array");
948
 
        },
949
 
     "Testing dd-ddm": function(data) {
950
 
            var loader = new Y.Loader({
951
 
                require: ["dd-ddm"],
952
 
                ignoreRegistered: true,
953
 
                allowRollup: false
954
 
            });
955
 
            loader.calculate();
956
 
            //Testing A normal module
957
 
            Assert.isTrue((loader.sorted.indexOf("dd-ddm")) > -1, "Module (dd-ddm) not found in sorted array");
958
 
        },
959
 
     "Testing dd-ddm-base": function(data) {
960
 
            var loader = new Y.Loader({
961
 
                require: ["dd-ddm-base"],
962
 
                ignoreRegistered: true,
963
 
                allowRollup: false
964
 
            });
965
 
            loader.calculate();
966
 
            //Testing A normal module
967
 
            Assert.isTrue((loader.sorted.indexOf("dd-ddm-base")) > -1, "Module (dd-ddm-base) not found in sorted array");
968
 
        },
969
 
     "Testing dd-ddm-drop": function(data) {
970
 
            var loader = new Y.Loader({
971
 
                require: ["dd-ddm-drop"],
972
 
                ignoreRegistered: true,
973
 
                allowRollup: false
974
 
            });
975
 
            loader.calculate();
976
 
            //Testing A normal module
977
 
            Assert.isTrue((loader.sorted.indexOf("dd-ddm-drop")) > -1, "Module (dd-ddm-drop) not found in sorted array");
978
 
        },
979
 
     "Testing dd-delegate": function(data) {
980
 
            var loader = new Y.Loader({
981
 
                require: ["dd-delegate"],
982
 
                ignoreRegistered: true,
983
 
                allowRollup: false
984
 
            });
985
 
            loader.calculate();
986
 
            //Testing A normal module
987
 
            Assert.isTrue((loader.sorted.indexOf("dd-delegate")) > -1, "Module (dd-delegate) not found in sorted array");
988
 
        },
989
 
     "Testing dd-drag": function(data) {
990
 
            var loader = new Y.Loader({
991
 
                require: ["dd-drag"],
992
 
                ignoreRegistered: true,
993
 
                allowRollup: false
994
 
            });
995
 
            loader.calculate();
996
 
            //Testing A normal module
997
 
            Assert.isTrue((loader.sorted.indexOf("dd-drag")) > -1, "Module (dd-drag) not found in sorted array");
998
 
        },
999
 
     "Testing dd-drop": function(data) {
1000
 
            var loader = new Y.Loader({
1001
 
                require: ["dd-drop"],
1002
 
                ignoreRegistered: true,
1003
 
                allowRollup: false
1004
 
            });
1005
 
            loader.calculate();
1006
 
            //Testing A normal module
1007
 
            Assert.isTrue((loader.sorted.indexOf("dd-drop")) > -1, "Module (dd-drop) not found in sorted array");
1008
 
        },
1009
 
     "Testing dd-drop-plugin": function(data) {
1010
 
            var loader = new Y.Loader({
1011
 
                require: ["dd-drop-plugin"],
1012
 
                ignoreRegistered: true,
1013
 
                allowRollup: false
1014
 
            });
1015
 
            loader.calculate();
1016
 
            //Testing A normal module
1017
 
            Assert.isTrue((loader.sorted.indexOf("dd-drop-plugin")) > -1, "Module (dd-drop-plugin) not found in sorted array");
1018
 
        },
1019
 
     "Testing dd-gestures": function(data) {
1020
 
            var loader = new Y.Loader({
1021
 
                require: ["dd-gestures"],
1022
 
                ignoreRegistered: true,
1023
 
                allowRollup: false
1024
 
            });
1025
 
            loader.calculate();
1026
 
            //Testing A normal module
1027
 
            Assert.isTrue((loader.sorted.indexOf("dd-gestures")) > -1, "Module (dd-gestures) not found in sorted array");
1028
 
        },
1029
 
     "Testing dd-plugin": function(data) {
1030
 
            var loader = new Y.Loader({
1031
 
                require: ["dd-plugin"],
1032
 
                ignoreRegistered: true,
1033
 
                allowRollup: false
1034
 
            });
1035
 
            loader.calculate();
1036
 
            //Testing A normal module
1037
 
            Assert.isTrue((loader.sorted.indexOf("dd-plugin")) > -1, "Module (dd-plugin) not found in sorted array");
1038
 
        },
1039
 
     "Testing dd-proxy": function(data) {
1040
 
            var loader = new Y.Loader({
1041
 
                require: ["dd-proxy"],
1042
 
                ignoreRegistered: true,
1043
 
                allowRollup: false
1044
 
            });
1045
 
            loader.calculate();
1046
 
            //Testing A normal module
1047
 
            Assert.isTrue((loader.sorted.indexOf("dd-proxy")) > -1, "Module (dd-proxy) not found in sorted array");
1048
 
        },
1049
 
     "Testing dd-scroll": function(data) {
1050
 
            var loader = new Y.Loader({
1051
 
                require: ["dd-scroll"],
1052
 
                ignoreRegistered: true,
1053
 
                allowRollup: false
1054
 
            });
1055
 
            loader.calculate();
1056
 
            //Testing A normal module
1057
 
            Assert.isTrue((loader.sorted.indexOf("dd-scroll")) > -1, "Module (dd-scroll) not found in sorted array");
1058
 
        },
1059
 
     "Testing dial": function(data) {
1060
 
            var loader = new Y.Loader({
1061
 
                require: ["dial"],
1062
 
                ignoreRegistered: true,
1063
 
                allowRollup: false
1064
 
            });
1065
 
            loader.calculate();
1066
 
            //Testing A normal module
1067
 
            Assert.isTrue((loader.sorted.indexOf("dial")) > -1, "Module (dial) not found in sorted array");
1068
 
        },
1069
 
     "Testing dom": function(data) {
1070
 
            var loader = new Y.Loader({
1071
 
                require: ["dom"],
1072
 
                ignoreRegistered: true,
1073
 
                allowRollup: false
1074
 
            });
1075
 
            loader.calculate();
1076
 
            //Testing A rollup module
1077
 
            Assert.isTrue((loader.sorted.indexOf("dom-base")) > -1, "Module (dom-base) not found in sorted array");
1078
 
            Assert.isTrue((loader.sorted.indexOf("dom-screen")) > -1, "Module (dom-screen) not found in sorted array");
1079
 
            Assert.isTrue((loader.sorted.indexOf("dom-style")) > -1, "Module (dom-style) not found in sorted array");
1080
 
            Assert.isTrue((loader.sorted.indexOf("selector-native")) > -1, "Module (selector-native) not found in sorted array");
1081
 
            Assert.isTrue((loader.sorted.indexOf("selector")) > -1, "Module (selector) not found in sorted array");
1082
 
        },
1083
 
     "Testing dom-base": function(data) {
1084
 
            var loader = new Y.Loader({
1085
 
                require: ["dom-base"],
1086
 
                ignoreRegistered: true,
1087
 
                allowRollup: false
1088
 
            });
1089
 
            loader.calculate();
1090
 
            //Testing A normal module
1091
 
            Assert.isTrue((loader.sorted.indexOf("dom-base")) > -1, "Module (dom-base) not found in sorted array");
1092
 
        },
1093
 
     "Testing dom-core": function(data) {
1094
 
            var loader = new Y.Loader({
1095
 
                require: ["dom-core"],
1096
 
                ignoreRegistered: true,
1097
 
                allowRollup: false
1098
 
            });
1099
 
            loader.calculate();
1100
 
            //Testing A normal module
1101
 
            Assert.isTrue((loader.sorted.indexOf("dom-core")) > -1, "Module (dom-core) not found in sorted array");
1102
 
        },
1103
 
     "Testing dom-deprecated": function(data) {
1104
 
            var loader = new Y.Loader({
1105
 
                require: ["dom-deprecated"],
1106
 
                ignoreRegistered: true,
1107
 
                allowRollup: false
1108
 
            });
1109
 
            loader.calculate();
1110
 
            //Testing A normal module
1111
 
            Assert.isTrue((loader.sorted.indexOf("dom-deprecated")) > -1, "Module (dom-deprecated) not found in sorted array");
1112
 
        },
1113
 
     "Testing dom-screen": function(data) {
1114
 
            var loader = new Y.Loader({
1115
 
                require: ["dom-screen"],
1116
 
                ignoreRegistered: true,
1117
 
                allowRollup: false
1118
 
            });
1119
 
            loader.calculate();
1120
 
            //Testing A normal module
1121
 
            Assert.isTrue((loader.sorted.indexOf("dom-screen")) > -1, "Module (dom-screen) not found in sorted array");
1122
 
        },
1123
 
     "Testing dom-style": function(data) {
1124
 
            var loader = new Y.Loader({
1125
 
                require: ["dom-style"],
1126
 
                ignoreRegistered: true,
1127
 
                allowRollup: false
1128
 
            });
1129
 
            loader.calculate();
1130
 
            //Testing A normal module
1131
 
            Assert.isTrue((loader.sorted.indexOf("dom-style")) > -1, "Module (dom-style) not found in sorted array");
1132
 
        },
1133
 
     "Testing dom-style-ie": function(data) {
1134
 
            var loader = new Y.Loader({
1135
 
                require: ["dom-style-ie"],
1136
 
                ignoreRegistered: true,
1137
 
                allowRollup: false
1138
 
            });
1139
 
            loader.calculate();
1140
 
            //Testing A normal module
1141
 
            Assert.isTrue((loader.sorted.indexOf("dom-style-ie")) > -1, "Module (dom-style-ie) not found in sorted array");
1142
 
        },
1143
 
     "Testing dump": function(data) {
1144
 
            var loader = new Y.Loader({
1145
 
                require: ["dump"],
1146
 
                ignoreRegistered: true,
1147
 
                allowRollup: false
1148
 
            });
1149
 
            loader.calculate();
1150
 
            //Testing A normal module
1151
 
            Assert.isTrue((loader.sorted.indexOf("dump")) > -1, "Module (dump) not found in sorted array");
1152
 
        },
1153
 
     "Testing editor": function(data) {
1154
 
            var loader = new Y.Loader({
1155
 
                require: ["editor"],
1156
 
                ignoreRegistered: true,
1157
 
                allowRollup: false
1158
 
            });
1159
 
            loader.calculate();
1160
 
            //Testing A rollup module
1161
 
            Assert.isTrue((loader.sorted.indexOf("frame")) > -1, "Module (frame) not found in sorted array");
1162
 
            Assert.isTrue((loader.sorted.indexOf("selection")) > -1, "Module (selection) not found in sorted array");
1163
 
            Assert.isTrue((loader.sorted.indexOf("exec-command")) > -1, "Module (exec-command) not found in sorted array");
1164
 
            Assert.isTrue((loader.sorted.indexOf("editor-base")) > -1, "Module (editor-base) not found in sorted array");
1165
 
            Assert.isTrue((loader.sorted.indexOf("editor-para")) > -1, "Module (editor-para) not found in sorted array");
1166
 
            Assert.isTrue((loader.sorted.indexOf("editor-br")) > -1, "Module (editor-br) not found in sorted array");
1167
 
            Assert.isTrue((loader.sorted.indexOf("editor-bidi")) > -1, "Module (editor-bidi) not found in sorted array");
1168
 
            Assert.isTrue((loader.sorted.indexOf("editor-tab")) > -1, "Module (editor-tab) not found in sorted array");
1169
 
            Assert.isTrue((loader.sorted.indexOf("createlink-base")) > -1, "Module (createlink-base) not found in sorted array");
1170
 
        },
1171
 
     "Testing editor-base": function(data) {
1172
 
            var loader = new Y.Loader({
1173
 
                require: ["editor-base"],
1174
 
                ignoreRegistered: true,
1175
 
                allowRollup: false
1176
 
            });
1177
 
            loader.calculate();
1178
 
            //Testing A normal module
1179
 
            Assert.isTrue((loader.sorted.indexOf("editor-base")) > -1, "Module (editor-base) not found in sorted array");
1180
 
        },
1181
 
     "Testing editor-bidi": function(data) {
1182
 
            var loader = new Y.Loader({
1183
 
                require: ["editor-bidi"],
1184
 
                ignoreRegistered: true,
1185
 
                allowRollup: false
1186
 
            });
1187
 
            loader.calculate();
1188
 
            //Testing A normal module
1189
 
            Assert.isTrue((loader.sorted.indexOf("editor-bidi")) > -1, "Module (editor-bidi) not found in sorted array");
1190
 
        },
1191
 
     "Testing editor-br": function(data) {
1192
 
            var loader = new Y.Loader({
1193
 
                require: ["editor-br"],
1194
 
                ignoreRegistered: true,
1195
 
                allowRollup: false
1196
 
            });
1197
 
            loader.calculate();
1198
 
            //Testing A normal module
1199
 
            Assert.isTrue((loader.sorted.indexOf("editor-br")) > -1, "Module (editor-br) not found in sorted array");
1200
 
        },
1201
 
     "Testing editor-lists": function(data) {
1202
 
            var loader = new Y.Loader({
1203
 
                require: ["editor-lists"],
1204
 
                ignoreRegistered: true,
1205
 
                allowRollup: false
1206
 
            });
1207
 
            loader.calculate();
1208
 
            //Testing A normal module
1209
 
            Assert.isTrue((loader.sorted.indexOf("editor-lists")) > -1, "Module (editor-lists) not found in sorted array");
1210
 
        },
1211
 
     "Testing editor-para": function(data) {
1212
 
            var loader = new Y.Loader({
1213
 
                require: ["editor-para"],
1214
 
                ignoreRegistered: true,
1215
 
                allowRollup: false
1216
 
            });
1217
 
            loader.calculate();
1218
 
            //Testing A normal module
1219
 
            Assert.isTrue((loader.sorted.indexOf("editor-para")) > -1, "Module (editor-para) not found in sorted array");
1220
 
        },
1221
 
     "Testing editor-tab": function(data) {
1222
 
            var loader = new Y.Loader({
1223
 
                require: ["editor-tab"],
1224
 
                ignoreRegistered: true,
1225
 
                allowRollup: false
1226
 
            });
1227
 
            loader.calculate();
1228
 
            //Testing A normal module
1229
 
            Assert.isTrue((loader.sorted.indexOf("editor-tab")) > -1, "Module (editor-tab) not found in sorted array");
1230
 
        },
1231
 
     "Testing escape": function(data) {
1232
 
            var loader = new Y.Loader({
1233
 
                require: ["escape"],
1234
 
                ignoreRegistered: true,
1235
 
                allowRollup: false
1236
 
            });
1237
 
            loader.calculate();
1238
 
            //Testing A normal module
1239
 
            Assert.isTrue((loader.sorted.indexOf("escape")) > -1, "Module (escape) not found in sorted array");
1240
 
        },
1241
 
     "Testing event": function(data) {
1242
 
            var loader = new Y.Loader({
1243
 
                require: ["event"],
1244
 
                ignoreRegistered: true,
1245
 
                allowRollup: false
1246
 
            });
1247
 
            loader.calculate();
1248
 
            //Testing A rollup module
1249
 
            Assert.isTrue((loader.sorted.indexOf("event-base")) > -1, "Module (event-base) not found in sorted array");
1250
 
            Assert.isTrue((loader.sorted.indexOf("event-delegate")) > -1, "Module (event-delegate) not found in sorted array");
1251
 
            Assert.isTrue((loader.sorted.indexOf("event-synthetic")) > -1, "Module (event-synthetic) not found in sorted array");
1252
 
            Assert.isTrue((loader.sorted.indexOf("event-mousewheel")) > -1, "Module (event-mousewheel) not found in sorted array");
1253
 
            Assert.isTrue((loader.sorted.indexOf("event-mouseenter")) > -1, "Module (event-mouseenter) not found in sorted array");
1254
 
            Assert.isTrue((loader.sorted.indexOf("event-key")) > -1, "Module (event-key) not found in sorted array");
1255
 
            Assert.isTrue((loader.sorted.indexOf("event-focus")) > -1, "Module (event-focus) not found in sorted array");
1256
 
            Assert.isTrue((loader.sorted.indexOf("event-resize")) > -1, "Module (event-resize) not found in sorted array");
1257
 
            Assert.isTrue((loader.sorted.indexOf("event-hover")) > -1, "Module (event-hover) not found in sorted array");
1258
 
            Assert.isTrue((loader.sorted.indexOf("event-outside")) > -1, "Module (event-outside) not found in sorted array");
1259
 
        },
1260
 
     "Testing event-base": function(data) {
1261
 
            var loader = new Y.Loader({
1262
 
                require: ["event-base"],
1263
 
                ignoreRegistered: true,
1264
 
                allowRollup: false
1265
 
            });
1266
 
            loader.calculate();
1267
 
            //Testing A normal module
1268
 
            Assert.isTrue((loader.sorted.indexOf("event-base")) > -1, "Module (event-base) not found in sorted array");
1269
 
        },
1270
 
     "Testing event-base-ie": function(data) {
1271
 
            var loader = new Y.Loader({
1272
 
                require: ["event-base-ie"],
1273
 
                ignoreRegistered: true,
1274
 
                allowRollup: false
1275
 
            });
1276
 
            loader.calculate();
1277
 
            //Testing A normal module
1278
 
            Assert.isTrue((loader.sorted.indexOf("event-base-ie")) > -1, "Module (event-base-ie) not found in sorted array");
1279
 
        },
1280
 
     "Testing event-custom": function(data) {
1281
 
            var loader = new Y.Loader({
1282
 
                require: ["event-custom"],
1283
 
                ignoreRegistered: true,
1284
 
                allowRollup: false
1285
 
            });
1286
 
            loader.calculate();
1287
 
            //Testing A rollup module
1288
 
            Assert.isTrue((loader.sorted.indexOf("event-custom-base")) > -1, "Module (event-custom-base) not found in sorted array");
1289
 
            Assert.isTrue((loader.sorted.indexOf("event-custom-complex")) > -1, "Module (event-custom-complex) not found in sorted array");
1290
 
        },
1291
 
     "Testing event-custom-base": function(data) {
1292
 
            var loader = new Y.Loader({
1293
 
                require: ["event-custom-base"],
1294
 
                ignoreRegistered: true,
1295
 
                allowRollup: false
1296
 
            });
1297
 
            loader.calculate();
1298
 
            //Testing A normal module
1299
 
            Assert.isTrue((loader.sorted.indexOf("event-custom-base")) > -1, "Module (event-custom-base) not found in sorted array");
1300
 
        },
1301
 
     "Testing event-custom-complex": function(data) {
1302
 
            var loader = new Y.Loader({
1303
 
                require: ["event-custom-complex"],
1304
 
                ignoreRegistered: true,
1305
 
                allowRollup: false
1306
 
            });
1307
 
            loader.calculate();
1308
 
            //Testing A normal module
1309
 
            Assert.isTrue((loader.sorted.indexOf("event-custom-complex")) > -1, "Module (event-custom-complex) not found in sorted array");
1310
 
        },
1311
 
     "Testing event-delegate": function(data) {
1312
 
            var loader = new Y.Loader({
1313
 
                require: ["event-delegate"],
1314
 
                ignoreRegistered: true,
1315
 
                allowRollup: false
1316
 
            });
1317
 
            loader.calculate();
1318
 
            //Testing A normal module
1319
 
            Assert.isTrue((loader.sorted.indexOf("event-delegate")) > -1, "Module (event-delegate) not found in sorted array");
1320
 
        },
1321
 
     "Testing event-flick": function(data) {
1322
 
            var loader = new Y.Loader({
1323
 
                require: ["event-flick"],
1324
 
                ignoreRegistered: true,
1325
 
                allowRollup: false
1326
 
            });
1327
 
            loader.calculate();
1328
 
            //Testing A normal module
1329
 
            Assert.isTrue((loader.sorted.indexOf("event-flick")) > -1, "Module (event-flick) not found in sorted array");
1330
 
        },
1331
 
     "Testing event-focus": function(data) {
1332
 
            var loader = new Y.Loader({
1333
 
                require: ["event-focus"],
1334
 
                ignoreRegistered: true,
1335
 
                allowRollup: false
1336
 
            });
1337
 
            loader.calculate();
1338
 
            //Testing A normal module
1339
 
            Assert.isTrue((loader.sorted.indexOf("event-focus")) > -1, "Module (event-focus) not found in sorted array");
1340
 
        },
1341
 
     "Testing event-gestures": function(data) {
1342
 
            var loader = new Y.Loader({
1343
 
                require: ["event-gestures"],
1344
 
                ignoreRegistered: true,
1345
 
                allowRollup: false
1346
 
            });
1347
 
            loader.calculate();
1348
 
            //Testing A rollup module
1349
 
            Assert.isTrue((loader.sorted.indexOf("event-flick")) > -1, "Module (event-flick) not found in sorted array");
1350
 
            Assert.isTrue((loader.sorted.indexOf("event-move")) > -1, "Module (event-move) not found in sorted array");
1351
 
        },
1352
 
     "Testing event-hover": function(data) {
1353
 
            var loader = new Y.Loader({
1354
 
                require: ["event-hover"],
1355
 
                ignoreRegistered: true,
1356
 
                allowRollup: false
1357
 
            });
1358
 
            loader.calculate();
1359
 
            //Testing A normal module
1360
 
            Assert.isTrue((loader.sorted.indexOf("event-hover")) > -1, "Module (event-hover) not found in sorted array");
1361
 
        },
1362
 
     "Testing event-key": function(data) {
1363
 
            var loader = new Y.Loader({
1364
 
                require: ["event-key"],
1365
 
                ignoreRegistered: true,
1366
 
                allowRollup: false
1367
 
            });
1368
 
            loader.calculate();
1369
 
            //Testing A normal module
1370
 
            Assert.isTrue((loader.sorted.indexOf("event-key")) > -1, "Module (event-key) not found in sorted array");
1371
 
        },
1372
 
     "Testing event-mouseenter": function(data) {
1373
 
            var loader = new Y.Loader({
1374
 
                require: ["event-mouseenter"],
1375
 
                ignoreRegistered: true,
1376
 
                allowRollup: false
1377
 
            });
1378
 
            loader.calculate();
1379
 
            //Testing A normal module
1380
 
            Assert.isTrue((loader.sorted.indexOf("event-mouseenter")) > -1, "Module (event-mouseenter) not found in sorted array");
1381
 
        },
1382
 
     "Testing event-mousewheel": function(data) {
1383
 
            var loader = new Y.Loader({
1384
 
                require: ["event-mousewheel"],
1385
 
                ignoreRegistered: true,
1386
 
                allowRollup: false
1387
 
            });
1388
 
            loader.calculate();
1389
 
            //Testing A normal module
1390
 
            Assert.isTrue((loader.sorted.indexOf("event-mousewheel")) > -1, "Module (event-mousewheel) not found in sorted array");
1391
 
        },
1392
 
     "Testing event-move": function(data) {
1393
 
            var loader = new Y.Loader({
1394
 
                require: ["event-move"],
1395
 
                ignoreRegistered: true,
1396
 
                allowRollup: false
1397
 
            });
1398
 
            loader.calculate();
1399
 
            //Testing A normal module
1400
 
            Assert.isTrue((loader.sorted.indexOf("event-move")) > -1, "Module (event-move) not found in sorted array");
1401
 
        },
1402
 
     "Testing event-outside": function(data) {
1403
 
            var loader = new Y.Loader({
1404
 
                require: ["event-outside"],
1405
 
                ignoreRegistered: true,
1406
 
                allowRollup: false
1407
 
            });
1408
 
            loader.calculate();
1409
 
            //Testing A normal module
1410
 
            Assert.isTrue((loader.sorted.indexOf("event-outside")) > -1, "Module (event-outside) not found in sorted array");
1411
 
        },
1412
 
     "Testing event-resize": function(data) {
1413
 
            var loader = new Y.Loader({
1414
 
                require: ["event-resize"],
1415
 
                ignoreRegistered: true,
1416
 
                allowRollup: false
1417
 
            });
1418
 
            loader.calculate();
1419
 
            //Testing A normal module
1420
 
            Assert.isTrue((loader.sorted.indexOf("event-resize")) > -1, "Module (event-resize) not found in sorted array");
1421
 
        },
1422
 
     "Testing event-simulate": function(data) {
1423
 
            var loader = new Y.Loader({
1424
 
                require: ["event-simulate"],
1425
 
                ignoreRegistered: true,
1426
 
                allowRollup: false
1427
 
            });
1428
 
            loader.calculate();
1429
 
            //Testing A normal module
1430
 
            Assert.isTrue((loader.sorted.indexOf("event-simulate")) > -1, "Module (event-simulate) not found in sorted array");
1431
 
        },
1432
 
     "Testing event-synthetic": function(data) {
1433
 
            var loader = new Y.Loader({
1434
 
                require: ["event-synthetic"],
1435
 
                ignoreRegistered: true,
1436
 
                allowRollup: false
1437
 
            });
1438
 
            loader.calculate();
1439
 
            //Testing A normal module
1440
 
            Assert.isTrue((loader.sorted.indexOf("event-synthetic")) > -1, "Module (event-synthetic) not found in sorted array");
1441
 
        },
1442
 
     "Testing event-touch": function(data) {
1443
 
            var loader = new Y.Loader({
1444
 
                require: ["event-touch"],
1445
 
                ignoreRegistered: true,
1446
 
                allowRollup: false
1447
 
            });
1448
 
            loader.calculate();
1449
 
            //Testing A normal module
1450
 
            Assert.isTrue((loader.sorted.indexOf("event-touch")) > -1, "Module (event-touch) not found in sorted array");
1451
 
        },
1452
 
     "Testing event-valuechange": function(data) {
1453
 
            var loader = new Y.Loader({
1454
 
                require: ["event-valuechange"],
1455
 
                ignoreRegistered: true,
1456
 
                allowRollup: false
1457
 
            });
1458
 
            loader.calculate();
1459
 
            //Testing A normal module
1460
 
            Assert.isTrue((loader.sorted.indexOf("event-valuechange")) > -1, "Module (event-valuechange) not found in sorted array");
1461
 
        },
1462
 
     "Testing exec-command": function(data) {
1463
 
            var loader = new Y.Loader({
1464
 
                require: ["exec-command"],
1465
 
                ignoreRegistered: true,
1466
 
                allowRollup: false
1467
 
            });
1468
 
            loader.calculate();
1469
 
            //Testing A normal module
1470
 
            Assert.isTrue((loader.sorted.indexOf("exec-command")) > -1, "Module (exec-command) not found in sorted array");
1471
 
        },
1472
 
     "Testing frame": function(data) {
1473
 
            var loader = new Y.Loader({
1474
 
                require: ["frame"],
1475
 
                ignoreRegistered: true,
1476
 
                allowRollup: false
1477
 
            });
1478
 
            loader.calculate();
1479
 
            //Testing A normal module
1480
 
            Assert.isTrue((loader.sorted.indexOf("frame")) > -1, "Module (frame) not found in sorted array");
1481
 
        },
1482
 
     "Testing graphics": function(data) {
1483
 
            var loader = new Y.Loader({
1484
 
                require: ["graphics"],
1485
 
                ignoreRegistered: true,
1486
 
                allowRollup: false
1487
 
            });
1488
 
            loader.calculate();
1489
 
            //Testing A normal module
1490
 
            Assert.isTrue((loader.sorted.indexOf("graphics")) > -1, "Module (graphics) not found in sorted array");
1491
 
        },
1492
 
     "Testing graphics-canvas": function(data) {
1493
 
            var loader = new Y.Loader({
1494
 
                require: ["graphics-canvas"],
1495
 
                ignoreRegistered: true,
1496
 
                allowRollup: false
1497
 
            });
1498
 
            loader.calculate();
1499
 
            //Testing A normal module
1500
 
            Assert.isTrue((loader.sorted.indexOf("graphics-canvas")) > -1, "Module (graphics-canvas) not found in sorted array");
1501
 
        },
1502
 
     "Testing graphics-canvas-default": function(data) {
1503
 
            var loader = new Y.Loader({
1504
 
                require: ["graphics-canvas-default"],
1505
 
                ignoreRegistered: true,
1506
 
                allowRollup: false
1507
 
            });
1508
 
            loader.calculate();
1509
 
            //Testing A normal module
1510
 
            Assert.isTrue((loader.sorted.indexOf("graphics-canvas-default")) > -1, "Module (graphics-canvas-default) not found in sorted array");
1511
 
        },
1512
 
     "Testing graphics-svg": function(data) {
1513
 
            var loader = new Y.Loader({
1514
 
                require: ["graphics-svg"],
1515
 
                ignoreRegistered: true,
1516
 
                allowRollup: false
1517
 
            });
1518
 
            loader.calculate();
1519
 
            //Testing A normal module
1520
 
            Assert.isTrue((loader.sorted.indexOf("graphics-svg")) > -1, "Module (graphics-svg) not found in sorted array");
1521
 
        },
1522
 
     "Testing graphics-svg-default": function(data) {
1523
 
            var loader = new Y.Loader({
1524
 
                require: ["graphics-svg-default"],
1525
 
                ignoreRegistered: true,
1526
 
                allowRollup: false
1527
 
            });
1528
 
            loader.calculate();
1529
 
            //Testing A normal module
1530
 
            Assert.isTrue((loader.sorted.indexOf("graphics-svg-default")) > -1, "Module (graphics-svg-default) not found in sorted array");
1531
 
        },
1532
 
     "Testing graphics-vml": function(data) {
1533
 
            var loader = new Y.Loader({
1534
 
                require: ["graphics-vml"],
1535
 
                ignoreRegistered: true,
1536
 
                allowRollup: false
1537
 
            });
1538
 
            loader.calculate();
1539
 
            //Testing A normal module
1540
 
            Assert.isTrue((loader.sorted.indexOf("graphics-vml")) > -1, "Module (graphics-vml) not found in sorted array");
1541
 
        },
1542
 
     "Testing graphics-vml-default": function(data) {
1543
 
            var loader = new Y.Loader({
1544
 
                require: ["graphics-vml-default"],
1545
 
                ignoreRegistered: true,
1546
 
                allowRollup: false
1547
 
            });
1548
 
            loader.calculate();
1549
 
            //Testing A normal module
1550
 
            Assert.isTrue((loader.sorted.indexOf("graphics-vml-default")) > -1, "Module (graphics-vml-default) not found in sorted array");
1551
 
        },
1552
 
     "Testing highlight": function(data) {
1553
 
            var loader = new Y.Loader({
1554
 
                require: ["highlight"],
1555
 
                ignoreRegistered: true,
1556
 
                allowRollup: false
1557
 
            });
1558
 
            loader.calculate();
1559
 
            //Testing A rollup module
1560
 
            Assert.isTrue((loader.sorted.indexOf("highlight-base")) > -1, "Module (highlight-base) not found in sorted array");
1561
 
            Assert.isTrue((loader.sorted.indexOf("highlight-accentfold")) > -1, "Module (highlight-accentfold) not found in sorted array");
1562
 
        },
1563
 
     "Testing highlight-accentfold": function(data) {
1564
 
            var loader = new Y.Loader({
1565
 
                require: ["highlight-accentfold"],
1566
 
                ignoreRegistered: true,
1567
 
                allowRollup: false
1568
 
            });
1569
 
            loader.calculate();
1570
 
            //Testing A normal module
1571
 
            Assert.isTrue((loader.sorted.indexOf("highlight-accentfold")) > -1, "Module (highlight-accentfold) not found in sorted array");
1572
 
        },
1573
 
     "Testing highlight-base": function(data) {
1574
 
            var loader = new Y.Loader({
1575
 
                require: ["highlight-base"],
1576
 
                ignoreRegistered: true,
1577
 
                allowRollup: false
1578
 
            });
1579
 
            loader.calculate();
1580
 
            //Testing A normal module
1581
 
            Assert.isTrue((loader.sorted.indexOf("highlight-base")) > -1, "Module (highlight-base) not found in sorted array");
1582
 
        },
1583
 
     "Testing history": function(data) {
1584
 
            var loader = new Y.Loader({
1585
 
                require: ["history"],
1586
 
                ignoreRegistered: true,
1587
 
                allowRollup: false
1588
 
            });
1589
 
            loader.calculate();
1590
 
            //Testing A rollup module
1591
 
            Assert.isTrue((loader.sorted.indexOf("history-base")) > -1, "Module (history-base) not found in sorted array");
1592
 
            Assert.isTrue((loader.sorted.indexOf("history-hash")) > -1, "Module (history-hash) not found in sorted array");
1593
 
            Assert.isTrue((loader.sorted.indexOf("history-hash-ie")) > -1, "Module (history-hash-ie) not found in sorted array");
1594
 
            Assert.isTrue((loader.sorted.indexOf("history-html5")) > -1, "Module (history-html5) not found in sorted array");
1595
 
        },
1596
 
     "Testing history-base": function(data) {
1597
 
            var loader = new Y.Loader({
1598
 
                require: ["history-base"],
1599
 
                ignoreRegistered: true,
1600
 
                allowRollup: false
1601
 
            });
1602
 
            loader.calculate();
1603
 
            //Testing A normal module
1604
 
            Assert.isTrue((loader.sorted.indexOf("history-base")) > -1, "Module (history-base) not found in sorted array");
1605
 
        },
1606
 
     "Testing history-hash": function(data) {
1607
 
            var loader = new Y.Loader({
1608
 
                require: ["history-hash"],
1609
 
                ignoreRegistered: true,
1610
 
                allowRollup: false
1611
 
            });
1612
 
            loader.calculate();
1613
 
            //Testing A normal module
1614
 
            Assert.isTrue((loader.sorted.indexOf("history-hash")) > -1, "Module (history-hash) not found in sorted array");
1615
 
        },
1616
 
     "Testing history-hash-ie": function(data) {
1617
 
            var loader = new Y.Loader({
1618
 
                require: ["history-hash-ie"],
1619
 
                ignoreRegistered: true,
1620
 
                allowRollup: false
1621
 
            });
1622
 
            loader.calculate();
1623
 
            //Testing A normal module
1624
 
            Assert.isTrue((loader.sorted.indexOf("history-hash-ie")) > -1, "Module (history-hash-ie) not found in sorted array");
1625
 
        },
1626
 
     "Testing history-html5": function(data) {
1627
 
            var loader = new Y.Loader({
1628
 
                require: ["history-html5"],
1629
 
                ignoreRegistered: true,
1630
 
                allowRollup: false
1631
 
            });
1632
 
            loader.calculate();
1633
 
            //Testing A normal module
1634
 
            Assert.isTrue((loader.sorted.indexOf("history-html5")) > -1, "Module (history-html5) not found in sorted array");
1635
 
        },
1636
 
     "Testing imageloader": function(data) {
1637
 
            var loader = new Y.Loader({
1638
 
                require: ["imageloader"],
1639
 
                ignoreRegistered: true,
1640
 
                allowRollup: false
1641
 
            });
1642
 
            loader.calculate();
1643
 
            //Testing A normal module
1644
 
            Assert.isTrue((loader.sorted.indexOf("imageloader")) > -1, "Module (imageloader) not found in sorted array");
1645
 
        },
1646
 
     "Testing intl": function(data) {
1647
 
            var loader = new Y.Loader({
1648
 
                require: ["intl"],
1649
 
                ignoreRegistered: true,
1650
 
                allowRollup: false
1651
 
            });
1652
 
            loader.calculate();
1653
 
            //Testing A normal module
1654
 
            Assert.isTrue((loader.sorted.indexOf("intl")) > -1, "Module (intl) not found in sorted array");
1655
 
        },
1656
 
     "Testing io": function(data) {
1657
 
            var loader = new Y.Loader({
1658
 
                require: ["io"],
1659
 
                ignoreRegistered: true,
1660
 
                allowRollup: false
1661
 
            });
1662
 
            loader.calculate();
1663
 
            //Testing A rollup module
1664
 
            Assert.isTrue((loader.sorted.indexOf("io-base")) > -1, "Module (io-base) not found in sorted array");
1665
 
            Assert.isTrue((loader.sorted.indexOf("io-xdr")) > -1, "Module (io-xdr) not found in sorted array");
1666
 
            Assert.isTrue((loader.sorted.indexOf("io-form")) > -1, "Module (io-form) not found in sorted array");
1667
 
            Assert.isTrue((loader.sorted.indexOf("io-upload-iframe")) > -1, "Module (io-upload-iframe) not found in sorted array");
1668
 
            Assert.isTrue((loader.sorted.indexOf("io-queue")) > -1, "Module (io-queue) not found in sorted array");
1669
 
        },
1670
 
     "Testing io-base": function(data) {
1671
 
            var loader = new Y.Loader({
1672
 
                require: ["io-base"],
1673
 
                ignoreRegistered: true,
1674
 
                allowRollup: false
1675
 
            });
1676
 
            loader.calculate();
1677
 
            //Testing A normal module
1678
 
            Assert.isTrue((loader.sorted.indexOf("io-base")) > -1, "Module (io-base) not found in sorted array");
1679
 
        },
1680
 
     "Testing io-form": function(data) {
1681
 
            var loader = new Y.Loader({
1682
 
                require: ["io-form"],
1683
 
                ignoreRegistered: true,
1684
 
                allowRollup: false
1685
 
            });
1686
 
            loader.calculate();
1687
 
            //Testing A normal module
1688
 
            Assert.isTrue((loader.sorted.indexOf("io-form")) > -1, "Module (io-form) not found in sorted array");
1689
 
        },
1690
 
     "Testing io-queue": function(data) {
1691
 
            var loader = new Y.Loader({
1692
 
                require: ["io-queue"],
1693
 
                ignoreRegistered: true,
1694
 
                allowRollup: false
1695
 
            });
1696
 
            loader.calculate();
1697
 
            //Testing A normal module
1698
 
            Assert.isTrue((loader.sorted.indexOf("io-queue")) > -1, "Module (io-queue) not found in sorted array");
1699
 
        },
1700
 
     "Testing io-upload-iframe": function(data) {
1701
 
            var loader = new Y.Loader({
1702
 
                require: ["io-upload-iframe"],
1703
 
                ignoreRegistered: true,
1704
 
                allowRollup: false
1705
 
            });
1706
 
            loader.calculate();
1707
 
            //Testing A normal module
1708
 
            Assert.isTrue((loader.sorted.indexOf("io-upload-iframe")) > -1, "Module (io-upload-iframe) not found in sorted array");
1709
 
        },
1710
 
     "Testing io-xdr": function(data) {
1711
 
            var loader = new Y.Loader({
1712
 
                require: ["io-xdr"],
1713
 
                ignoreRegistered: true,
1714
 
                allowRollup: false
1715
 
            });
1716
 
            loader.calculate();
1717
 
            //Testing A normal module
1718
 
            Assert.isTrue((loader.sorted.indexOf("io-xdr")) > -1, "Module (io-xdr) not found in sorted array");
1719
 
        },
1720
 
     "Testing json": function(data) {
1721
 
            var loader = new Y.Loader({
1722
 
                require: ["json"],
1723
 
                ignoreRegistered: true,
1724
 
                allowRollup: false
1725
 
            });
1726
 
            loader.calculate();
1727
 
            //Testing A rollup module
1728
 
            Assert.isTrue((loader.sorted.indexOf("json-parse")) > -1, "Module (json-parse) not found in sorted array");
1729
 
            Assert.isTrue((loader.sorted.indexOf("json-stringify")) > -1, "Module (json-stringify) not found in sorted array");
1730
 
        },
1731
 
     "Testing json-parse": function(data) {
1732
 
            var loader = new Y.Loader({
1733
 
                require: ["json-parse"],
1734
 
                ignoreRegistered: true,
1735
 
                allowRollup: false
1736
 
            });
1737
 
            loader.calculate();
1738
 
            //Testing A normal module
1739
 
            Assert.isTrue((loader.sorted.indexOf("json-parse")) > -1, "Module (json-parse) not found in sorted array");
1740
 
        },
1741
 
     "Testing json-stringify": function(data) {
1742
 
            var loader = new Y.Loader({
1743
 
                require: ["json-stringify"],
1744
 
                ignoreRegistered: true,
1745
 
                allowRollup: false
1746
 
            });
1747
 
            loader.calculate();
1748
 
            //Testing A normal module
1749
 
            Assert.isTrue((loader.sorted.indexOf("json-stringify")) > -1, "Module (json-stringify) not found in sorted array");
1750
 
        },
1751
 
     "Testing jsonp": function(data) {
1752
 
            var loader = new Y.Loader({
1753
 
                require: ["jsonp"],
1754
 
                ignoreRegistered: true,
1755
 
                allowRollup: false
1756
 
            });
1757
 
            loader.calculate();
1758
 
            //Testing A normal module
1759
 
            Assert.isTrue((loader.sorted.indexOf("jsonp")) > -1, "Module (jsonp) not found in sorted array");
1760
 
        },
1761
 
     "Testing jsonp-url": function(data) {
1762
 
            var loader = new Y.Loader({
1763
 
                require: ["jsonp-url"],
1764
 
                ignoreRegistered: true,
1765
 
                allowRollup: false
1766
 
            });
1767
 
            loader.calculate();
1768
 
            //Testing A normal module
1769
 
            Assert.isTrue((loader.sorted.indexOf("jsonp-url")) > -1, "Module (jsonp-url) not found in sorted array");
1770
 
        },
1771
 
     "Testing model": function(data) {
1772
 
            var loader = new Y.Loader({
1773
 
                require: ["model"],
1774
 
                ignoreRegistered: true,
1775
 
                allowRollup: false
1776
 
            });
1777
 
            loader.calculate();
1778
 
            //Testing A normal module
1779
 
            Assert.isTrue((loader.sorted.indexOf("model")) > -1, "Module (model) not found in sorted array");
1780
 
        },
1781
 
     "Testing model-list": function(data) {
1782
 
            var loader = new Y.Loader({
1783
 
                require: ["model-list"],
1784
 
                ignoreRegistered: true,
1785
 
                allowRollup: false
1786
 
            });
1787
 
            loader.calculate();
1788
 
            //Testing A normal module
1789
 
            Assert.isTrue((loader.sorted.indexOf("model-list")) > -1, "Module (model-list) not found in sorted array");
1790
 
        },
1791
 
     "Testing node": function(data) {
1792
 
            var loader = new Y.Loader({
1793
 
                require: ["node"],
1794
 
                ignoreRegistered: true,
1795
 
                allowRollup: false
1796
 
            });
1797
 
            loader.calculate();
1798
 
            //Testing A rollup module
1799
 
            Assert.isTrue((loader.sorted.indexOf("node-base")) > -1, "Module (node-base) not found in sorted array");
1800
 
            Assert.isTrue((loader.sorted.indexOf("node-event-delegate")) > -1, "Module (node-event-delegate) not found in sorted array");
1801
 
            Assert.isTrue((loader.sorted.indexOf("node-pluginhost")) > -1, "Module (node-pluginhost) not found in sorted array");
1802
 
            Assert.isTrue((loader.sorted.indexOf("node-screen")) > -1, "Module (node-screen) not found in sorted array");
1803
 
            Assert.isTrue((loader.sorted.indexOf("node-style")) > -1, "Module (node-style) not found in sorted array");
1804
 
        },
1805
 
     "Testing node-base": function(data) {
1806
 
            var loader = new Y.Loader({
1807
 
                require: ["node-base"],
1808
 
                ignoreRegistered: true,
1809
 
                allowRollup: false
1810
 
            });
1811
 
            loader.calculate();
1812
 
            //Testing A normal module
1813
 
            Assert.isTrue((loader.sorted.indexOf("node-base")) > -1, "Module (node-base) not found in sorted array");
1814
 
        },
1815
 
     "Testing node-core": function(data) {
1816
 
            var loader = new Y.Loader({
1817
 
                require: ["node-core"],
1818
 
                ignoreRegistered: true,
1819
 
                allowRollup: false
1820
 
            });
1821
 
            loader.calculate();
1822
 
            //Testing A normal module
1823
 
            Assert.isTrue((loader.sorted.indexOf("node-core")) > -1, "Module (node-core) not found in sorted array");
1824
 
        },
1825
 
     "Testing node-deprecated": function(data) {
1826
 
            var loader = new Y.Loader({
1827
 
                require: ["node-deprecated"],
1828
 
                ignoreRegistered: true,
1829
 
                allowRollup: false
1830
 
            });
1831
 
            loader.calculate();
1832
 
            //Testing A normal module
1833
 
            Assert.isTrue((loader.sorted.indexOf("node-deprecated")) > -1, "Module (node-deprecated) not found in sorted array");
1834
 
        },
1835
 
     "Testing node-event-delegate": function(data) {
1836
 
            var loader = new Y.Loader({
1837
 
                require: ["node-event-delegate"],
1838
 
                ignoreRegistered: true,
1839
 
                allowRollup: false
1840
 
            });
1841
 
            loader.calculate();
1842
 
            //Testing A normal module
1843
 
            Assert.isTrue((loader.sorted.indexOf("node-event-delegate")) > -1, "Module (node-event-delegate) not found in sorted array");
1844
 
        },
1845
 
     "Testing node-event-html5": function(data) {
1846
 
            var loader = new Y.Loader({
1847
 
                require: ["node-event-html5"],
1848
 
                ignoreRegistered: true,
1849
 
                allowRollup: false
1850
 
            });
1851
 
            loader.calculate();
1852
 
            //Testing A normal module
1853
 
            Assert.isTrue((loader.sorted.indexOf("node-event-html5")) > -1, "Module (node-event-html5) not found in sorted array");
1854
 
        },
1855
 
     "Testing node-event-simulate": function(data) {
1856
 
            var loader = new Y.Loader({
1857
 
                require: ["node-event-simulate"],
1858
 
                ignoreRegistered: true,
1859
 
                allowRollup: false
1860
 
            });
1861
 
            loader.calculate();
1862
 
            //Testing A normal module
1863
 
            Assert.isTrue((loader.sorted.indexOf("node-event-simulate")) > -1, "Module (node-event-simulate) not found in sorted array");
1864
 
        },
1865
 
     "Testing node-flick": function(data) {
1866
 
            var loader = new Y.Loader({
1867
 
                require: ["node-flick"],
1868
 
                ignoreRegistered: true,
1869
 
                allowRollup: false
1870
 
            });
1871
 
            loader.calculate();
1872
 
            //Testing A normal module
1873
 
            Assert.isTrue((loader.sorted.indexOf("node-flick")) > -1, "Module (node-flick) not found in sorted array");
1874
 
        },
1875
 
     "Testing node-focusmanager": function(data) {
1876
 
            var loader = new Y.Loader({
1877
 
                require: ["node-focusmanager"],
1878
 
                ignoreRegistered: true,
1879
 
                allowRollup: false
1880
 
            });
1881
 
            loader.calculate();
1882
 
            //Testing A normal module
1883
 
            Assert.isTrue((loader.sorted.indexOf("node-focusmanager")) > -1, "Module (node-focusmanager) not found in sorted array");
1884
 
        },
1885
 
     "Testing node-load": function(data) {
1886
 
            var loader = new Y.Loader({
1887
 
                require: ["node-load"],
1888
 
                ignoreRegistered: true,
1889
 
                allowRollup: false
1890
 
            });
1891
 
            loader.calculate();
1892
 
            //Testing A normal module
1893
 
            Assert.isTrue((loader.sorted.indexOf("node-load")) > -1, "Module (node-load) not found in sorted array");
1894
 
        },
1895
 
     "Testing node-menunav": function(data) {
1896
 
            var loader = new Y.Loader({
1897
 
                require: ["node-menunav"],
1898
 
                ignoreRegistered: true,
1899
 
                allowRollup: false
1900
 
            });
1901
 
            loader.calculate();
1902
 
            //Testing A normal module
1903
 
            Assert.isTrue((loader.sorted.indexOf("node-menunav")) > -1, "Module (node-menunav) not found in sorted array");
1904
 
        },
1905
 
     "Testing node-pluginhost": function(data) {
1906
 
            var loader = new Y.Loader({
1907
 
                require: ["node-pluginhost"],
1908
 
                ignoreRegistered: true,
1909
 
                allowRollup: false
1910
 
            });
1911
 
            loader.calculate();
1912
 
            //Testing A normal module
1913
 
            Assert.isTrue((loader.sorted.indexOf("node-pluginhost")) > -1, "Module (node-pluginhost) not found in sorted array");
1914
 
        },
1915
 
     "Testing node-screen": function(data) {
1916
 
            var loader = new Y.Loader({
1917
 
                require: ["node-screen"],
1918
 
                ignoreRegistered: true,
1919
 
                allowRollup: false
1920
 
            });
1921
 
            loader.calculate();
1922
 
            //Testing A normal module
1923
 
            Assert.isTrue((loader.sorted.indexOf("node-screen")) > -1, "Module (node-screen) not found in sorted array");
1924
 
        },
1925
 
     "Testing node-style": function(data) {
1926
 
            var loader = new Y.Loader({
1927
 
                require: ["node-style"],
1928
 
                ignoreRegistered: true,
1929
 
                allowRollup: false
1930
 
            });
1931
 
            loader.calculate();
1932
 
            //Testing A normal module
1933
 
            Assert.isTrue((loader.sorted.indexOf("node-style")) > -1, "Module (node-style) not found in sorted array");
1934
 
        },
1935
 
     "Testing oop": function(data) {
1936
 
            var loader = new Y.Loader({
1937
 
                require: ["oop"],
1938
 
                ignoreRegistered: true,
1939
 
                allowRollup: false
1940
 
            });
1941
 
            loader.calculate();
1942
 
            //Testing A normal module
1943
 
            Assert.isTrue((loader.sorted.indexOf("oop")) > -1, "Module (oop) not found in sorted array");
1944
 
        },
1945
 
     "Testing overlay": function(data) {
1946
 
            var loader = new Y.Loader({
1947
 
                require: ["overlay"],
1948
 
                ignoreRegistered: true,
1949
 
                allowRollup: false
1950
 
            });
1951
 
            loader.calculate();
1952
 
            //Testing A normal module
1953
 
            Assert.isTrue((loader.sorted.indexOf("overlay")) > -1, "Module (overlay) not found in sorted array");
1954
 
        },
1955
 
     "Testing panel": function(data) {
1956
 
            var loader = new Y.Loader({
1957
 
                require: ["panel"],
1958
 
                ignoreRegistered: true,
1959
 
                allowRollup: false
1960
 
            });
1961
 
            loader.calculate();
1962
 
            //Testing A normal module
1963
 
            Assert.isTrue((loader.sorted.indexOf("panel")) > -1, "Module (panel) not found in sorted array");
1964
 
        },
1965
 
     "Testing plugin": function(data) {
1966
 
            var loader = new Y.Loader({
1967
 
                require: ["plugin"],
1968
 
                ignoreRegistered: true,
1969
 
                allowRollup: false
1970
 
            });
1971
 
            loader.calculate();
1972
 
            //Testing A normal module
1973
 
            Assert.isTrue((loader.sorted.indexOf("plugin")) > -1, "Module (plugin) not found in sorted array");
1974
 
        },
1975
 
     "Testing pluginhost": function(data) {
1976
 
            var loader = new Y.Loader({
1977
 
                require: ["pluginhost"],
1978
 
                ignoreRegistered: true,
1979
 
                allowRollup: false
1980
 
            });
1981
 
            loader.calculate();
1982
 
            //Testing A rollup module
1983
 
            Assert.isTrue((loader.sorted.indexOf("pluginhost-base")) > -1, "Module (pluginhost-base) not found in sorted array");
1984
 
            Assert.isTrue((loader.sorted.indexOf("pluginhost-config")) > -1, "Module (pluginhost-config) not found in sorted array");
1985
 
        },
1986
 
     "Testing pluginhost-base": function(data) {
1987
 
            var loader = new Y.Loader({
1988
 
                require: ["pluginhost-base"],
1989
 
                ignoreRegistered: true,
1990
 
                allowRollup: false
1991
 
            });
1992
 
            loader.calculate();
1993
 
            //Testing A normal module
1994
 
            Assert.isTrue((loader.sorted.indexOf("pluginhost-base")) > -1, "Module (pluginhost-base) not found in sorted array");
1995
 
        },
1996
 
     "Testing pluginhost-config": function(data) {
1997
 
            var loader = new Y.Loader({
1998
 
                require: ["pluginhost-config"],
1999
 
                ignoreRegistered: true,
2000
 
                allowRollup: false
2001
 
            });
2002
 
            loader.calculate();
2003
 
            //Testing A normal module
2004
 
            Assert.isTrue((loader.sorted.indexOf("pluginhost-config")) > -1, "Module (pluginhost-config) not found in sorted array");
2005
 
        },
2006
 
     "Testing profiler": function(data) {
2007
 
            var loader = new Y.Loader({
2008
 
                require: ["profiler"],
2009
 
                ignoreRegistered: true,
2010
 
                allowRollup: false
2011
 
            });
2012
 
            loader.calculate();
2013
 
            //Testing A normal module
2014
 
            Assert.isTrue((loader.sorted.indexOf("profiler")) > -1, "Module (profiler) not found in sorted array");
2015
 
        },
2016
 
     "Testing querystring": function(data) {
2017
 
            var loader = new Y.Loader({
2018
 
                require: ["querystring"],
2019
 
                ignoreRegistered: true,
2020
 
                allowRollup: false
2021
 
            });
2022
 
            loader.calculate();
2023
 
            //Testing A rollup module
2024
 
            Assert.isTrue((loader.sorted.indexOf("querystring-parse")) > -1, "Module (querystring-parse) not found in sorted array");
2025
 
            Assert.isTrue((loader.sorted.indexOf("querystring-stringify")) > -1, "Module (querystring-stringify) not found in sorted array");
2026
 
        },
2027
 
     "Testing querystring-parse": function(data) {
2028
 
            var loader = new Y.Loader({
2029
 
                require: ["querystring-parse"],
2030
 
                ignoreRegistered: true,
2031
 
                allowRollup: false
2032
 
            });
2033
 
            loader.calculate();
2034
 
            //Testing A normal module
2035
 
            Assert.isTrue((loader.sorted.indexOf("querystring-parse")) > -1, "Module (querystring-parse) not found in sorted array");
2036
 
        },
2037
 
     "Testing querystring-parse-simple": function(data) {
2038
 
            var loader = new Y.Loader({
2039
 
                require: ["querystring-parse-simple"],
2040
 
                ignoreRegistered: true,
2041
 
                allowRollup: false
2042
 
            });
2043
 
            loader.calculate();
2044
 
            //Testing A normal module
2045
 
            Assert.isTrue((loader.sorted.indexOf("querystring-parse-simple")) > -1, "Module (querystring-parse-simple) not found in sorted array");
2046
 
        },
2047
 
     "Testing querystring-stringify": function(data) {
2048
 
            var loader = new Y.Loader({
2049
 
                require: ["querystring-stringify"],
2050
 
                ignoreRegistered: true,
2051
 
                allowRollup: false
2052
 
            });
2053
 
            loader.calculate();
2054
 
            //Testing A normal module
2055
 
            Assert.isTrue((loader.sorted.indexOf("querystring-stringify")) > -1, "Module (querystring-stringify) not found in sorted array");
2056
 
        },
2057
 
     "Testing querystring-stringify-simple": function(data) {
2058
 
            var loader = new Y.Loader({
2059
 
                require: ["querystring-stringify-simple"],
2060
 
                ignoreRegistered: true,
2061
 
                allowRollup: false
2062
 
            });
2063
 
            loader.calculate();
2064
 
            //Testing A normal module
2065
 
            Assert.isTrue((loader.sorted.indexOf("querystring-stringify-simple")) > -1, "Module (querystring-stringify-simple) not found in sorted array");
2066
 
        },
2067
 
     "Testing queue-promote": function(data) {
2068
 
            var loader = new Y.Loader({
2069
 
                require: ["queue-promote"],
2070
 
                ignoreRegistered: true,
2071
 
                allowRollup: false
2072
 
            });
2073
 
            loader.calculate();
2074
 
            //Testing A normal module
2075
 
            Assert.isTrue((loader.sorted.indexOf("queue-promote")) > -1, "Module (queue-promote) not found in sorted array");
2076
 
        },
2077
 
     "Testing range-slider": function(data) {
2078
 
            var loader = new Y.Loader({
2079
 
                require: ["range-slider"],
2080
 
                ignoreRegistered: true,
2081
 
                allowRollup: false
2082
 
            });
2083
 
            loader.calculate();
2084
 
            //Testing A normal module
2085
 
            Assert.isTrue((loader.sorted.indexOf("range-slider")) > -1, "Module (range-slider) not found in sorted array");
2086
 
        },
2087
 
     "Testing recordset": function(data) {
2088
 
            var loader = new Y.Loader({
2089
 
                require: ["recordset"],
2090
 
                ignoreRegistered: true,
2091
 
                allowRollup: false
2092
 
            });
2093
 
            loader.calculate();
2094
 
            //Testing A rollup module
2095
 
            Assert.isTrue((loader.sorted.indexOf("recordset-base")) > -1, "Module (recordset-base) not found in sorted array");
2096
 
            Assert.isTrue((loader.sorted.indexOf("recordset-sort")) > -1, "Module (recordset-sort) not found in sorted array");
2097
 
            Assert.isTrue((loader.sorted.indexOf("recordset-filter")) > -1, "Module (recordset-filter) not found in sorted array");
2098
 
            Assert.isTrue((loader.sorted.indexOf("recordset-indexer")) > -1, "Module (recordset-indexer) not found in sorted array");
2099
 
        },
2100
 
     "Testing recordset-base": function(data) {
2101
 
            var loader = new Y.Loader({
2102
 
                require: ["recordset-base"],
2103
 
                ignoreRegistered: true,
2104
 
                allowRollup: false
2105
 
            });
2106
 
            loader.calculate();
2107
 
            //Testing A normal module
2108
 
            Assert.isTrue((loader.sorted.indexOf("recordset-base")) > -1, "Module (recordset-base) not found in sorted array");
2109
 
        },
2110
 
     "Testing recordset-filter": function(data) {
2111
 
            var loader = new Y.Loader({
2112
 
                require: ["recordset-filter"],
2113
 
                ignoreRegistered: true,
2114
 
                allowRollup: false
2115
 
            });
2116
 
            loader.calculate();
2117
 
            //Testing A normal module
2118
 
            Assert.isTrue((loader.sorted.indexOf("recordset-filter")) > -1, "Module (recordset-filter) not found in sorted array");
2119
 
        },
2120
 
     "Testing recordset-indexer": function(data) {
2121
 
            var loader = new Y.Loader({
2122
 
                require: ["recordset-indexer"],
2123
 
                ignoreRegistered: true,
2124
 
                allowRollup: false
2125
 
            });
2126
 
            loader.calculate();
2127
 
            //Testing A normal module
2128
 
            Assert.isTrue((loader.sorted.indexOf("recordset-indexer")) > -1, "Module (recordset-indexer) not found in sorted array");
2129
 
        },
2130
 
     "Testing recordset-sort": function(data) {
2131
 
            var loader = new Y.Loader({
2132
 
                require: ["recordset-sort"],
2133
 
                ignoreRegistered: true,
2134
 
                allowRollup: false
2135
 
            });
2136
 
            loader.calculate();
2137
 
            //Testing A normal module
2138
 
            Assert.isTrue((loader.sorted.indexOf("recordset-sort")) > -1, "Module (recordset-sort) not found in sorted array");
2139
 
        },
2140
 
     "Testing resize": function(data) {
2141
 
            var loader = new Y.Loader({
2142
 
                require: ["resize"],
2143
 
                ignoreRegistered: true,
2144
 
                allowRollup: false
2145
 
            });
2146
 
            loader.calculate();
2147
 
            //Testing A rollup module
2148
 
            Assert.isTrue((loader.sorted.indexOf("resize-base")) > -1, "Module (resize-base) not found in sorted array");
2149
 
            Assert.isTrue((loader.sorted.indexOf("resize-proxy")) > -1, "Module (resize-proxy) not found in sorted array");
2150
 
            Assert.isTrue((loader.sorted.indexOf("resize-constrain")) > -1, "Module (resize-constrain) not found in sorted array");
2151
 
        },
2152
 
     "Testing resize-base": function(data) {
2153
 
            var loader = new Y.Loader({
2154
 
                require: ["resize-base"],
2155
 
                ignoreRegistered: true,
2156
 
                allowRollup: false
2157
 
            });
2158
 
            loader.calculate();
2159
 
            //Testing A normal module
2160
 
            Assert.isTrue((loader.sorted.indexOf("resize-base")) > -1, "Module (resize-base) not found in sorted array");
2161
 
        },
2162
 
     "Testing resize-constrain": function(data) {
2163
 
            var loader = new Y.Loader({
2164
 
                require: ["resize-constrain"],
2165
 
                ignoreRegistered: true,
2166
 
                allowRollup: false
2167
 
            });
2168
 
            loader.calculate();
2169
 
            //Testing A normal module
2170
 
            Assert.isTrue((loader.sorted.indexOf("resize-constrain")) > -1, "Module (resize-constrain) not found in sorted array");
2171
 
        },
2172
 
     "Testing resize-plugin": function(data) {
2173
 
            var loader = new Y.Loader({
2174
 
                require: ["resize-plugin"],
2175
 
                ignoreRegistered: true,
2176
 
                allowRollup: false
2177
 
            });
2178
 
            loader.calculate();
2179
 
            //Testing A normal module
2180
 
            Assert.isTrue((loader.sorted.indexOf("resize-plugin")) > -1, "Module (resize-plugin) not found in sorted array");
2181
 
        },
2182
 
     "Testing resize-proxy": function(data) {
2183
 
            var loader = new Y.Loader({
2184
 
                require: ["resize-proxy"],
2185
 
                ignoreRegistered: true,
2186
 
                allowRollup: false
2187
 
            });
2188
 
            loader.calculate();
2189
 
            //Testing A normal module
2190
 
            Assert.isTrue((loader.sorted.indexOf("resize-proxy")) > -1, "Module (resize-proxy) not found in sorted array");
2191
 
        },
2192
 
     "Testing rls": function(data) {
2193
 
            var loader = new Y.Loader({
2194
 
                require: ["rls"],
2195
 
                ignoreRegistered: true,
2196
 
                allowRollup: false
2197
 
            });
2198
 
            loader.calculate();
2199
 
            //Testing A normal module
2200
 
            Assert.isTrue((loader.sorted.indexOf("rls")) > -1, "Module (rls) not found in sorted array");
2201
 
        },
2202
 
     "Testing scrollview": function(data) {
2203
 
            var loader = new Y.Loader({
2204
 
                require: ["scrollview"],
2205
 
                ignoreRegistered: true,
2206
 
                allowRollup: false
2207
 
            });
2208
 
            loader.calculate();
2209
 
            //Testing A normal module
2210
 
            Assert.isTrue((loader.sorted.indexOf("scrollview")) > -1, "Module (scrollview) not found in sorted array");
2211
 
        },
2212
 
     "Testing scrollview-base": function(data) {
2213
 
            var loader = new Y.Loader({
2214
 
                require: ["scrollview-base"],
2215
 
                ignoreRegistered: true,
2216
 
                allowRollup: false
2217
 
            });
2218
 
            loader.calculate();
2219
 
            //Testing A normal module
2220
 
            Assert.isTrue((loader.sorted.indexOf("scrollview-base")) > -1, "Module (scrollview-base) not found in sorted array");
2221
 
        },
2222
 
     "Testing scrollview-base-ie": function(data) {
2223
 
            var loader = new Y.Loader({
2224
 
                require: ["scrollview-base-ie"],
2225
 
                ignoreRegistered: true,
2226
 
                allowRollup: false
2227
 
            });
2228
 
            loader.calculate();
2229
 
            //Testing A normal module
2230
 
            Assert.isTrue((loader.sorted.indexOf("scrollview-base-ie")) > -1, "Module (scrollview-base-ie) not found in sorted array");
2231
 
        },
2232
 
     "Testing scrollview-list": function(data) {
2233
 
            var loader = new Y.Loader({
2234
 
                require: ["scrollview-list"],
2235
 
                ignoreRegistered: true,
2236
 
                allowRollup: false
2237
 
            });
2238
 
            loader.calculate();
2239
 
            //Testing A normal module
2240
 
            Assert.isTrue((loader.sorted.indexOf("scrollview-list")) > -1, "Module (scrollview-list) not found in sorted array");
2241
 
        },
2242
 
     "Testing scrollview-paginator": function(data) {
2243
 
            var loader = new Y.Loader({
2244
 
                require: ["scrollview-paginator"],
2245
 
                ignoreRegistered: true,
2246
 
                allowRollup: false
2247
 
            });
2248
 
            loader.calculate();
2249
 
            //Testing A normal module
2250
 
            Assert.isTrue((loader.sorted.indexOf("scrollview-paginator")) > -1, "Module (scrollview-paginator) not found in sorted array");
2251
 
        },
2252
 
     "Testing scrollview-scrollbars": function(data) {
2253
 
            var loader = new Y.Loader({
2254
 
                require: ["scrollview-scrollbars"],
2255
 
                ignoreRegistered: true,
2256
 
                allowRollup: false
2257
 
            });
2258
 
            loader.calculate();
2259
 
            //Testing A normal module
2260
 
            Assert.isTrue((loader.sorted.indexOf("scrollview-scrollbars")) > -1, "Module (scrollview-scrollbars) not found in sorted array");
2261
 
        },
2262
 
     "Testing selection": function(data) {
2263
 
            var loader = new Y.Loader({
2264
 
                require: ["selection"],
2265
 
                ignoreRegistered: true,
2266
 
                allowRollup: false
2267
 
            });
2268
 
            loader.calculate();
2269
 
            //Testing A normal module
2270
 
            Assert.isTrue((loader.sorted.indexOf("selection")) > -1, "Module (selection) not found in sorted array");
2271
 
        },
2272
 
     "Testing selector": function(data) {
2273
 
            var loader = new Y.Loader({
2274
 
                require: ["selector"],
2275
 
                ignoreRegistered: true,
2276
 
                allowRollup: false
2277
 
            });
2278
 
            loader.calculate();
2279
 
            //Testing A normal module
2280
 
            Assert.isTrue((loader.sorted.indexOf("selector")) > -1, "Module (selector) not found in sorted array");
2281
 
        },
2282
 
     "Testing selector-native": function(data) {
2283
 
            var loader = new Y.Loader({
2284
 
                require: ["selector-native"],
2285
 
                ignoreRegistered: true,
2286
 
                allowRollup: false
2287
 
            });
2288
 
            loader.calculate();
2289
 
            //Testing A normal module
2290
 
            Assert.isTrue((loader.sorted.indexOf("selector-native")) > -1, "Module (selector-native) not found in sorted array");
2291
 
        },
2292
 
     "Testing shim-plugin": function(data) {
2293
 
            var loader = new Y.Loader({
2294
 
                require: ["shim-plugin"],
2295
 
                ignoreRegistered: true,
2296
 
                allowRollup: false
2297
 
            });
2298
 
            loader.calculate();
2299
 
            //Testing A normal module
2300
 
            Assert.isTrue((loader.sorted.indexOf("shim-plugin")) > -1, "Module (shim-plugin) not found in sorted array");
2301
 
        },
2302
 
     "Testing slider": function(data) {
2303
 
            var loader = new Y.Loader({
2304
 
                require: ["slider"],
2305
 
                ignoreRegistered: true,
2306
 
                allowRollup: false
2307
 
            });
2308
 
            loader.calculate();
2309
 
            //Testing A rollup module
2310
 
            Assert.isTrue((loader.sorted.indexOf("slider-base")) > -1, "Module (slider-base) not found in sorted array");
2311
 
            Assert.isTrue((loader.sorted.indexOf("slider-value-range")) > -1, "Module (slider-value-range) not found in sorted array");
2312
 
            Assert.isTrue((loader.sorted.indexOf("clickable-rail")) > -1, "Module (clickable-rail) not found in sorted array");
2313
 
            Assert.isTrue((loader.sorted.indexOf("range-slider")) > -1, "Module (range-slider) not found in sorted array");
2314
 
        },
2315
 
     "Testing slider-base": function(data) {
2316
 
            var loader = new Y.Loader({
2317
 
                require: ["slider-base"],
2318
 
                ignoreRegistered: true,
2319
 
                allowRollup: false
2320
 
            });
2321
 
            loader.calculate();
2322
 
            //Testing A normal module
2323
 
            Assert.isTrue((loader.sorted.indexOf("slider-base")) > -1, "Module (slider-base) not found in sorted array");
2324
 
        },
2325
 
     "Testing slider-value-range": function(data) {
2326
 
            var loader = new Y.Loader({
2327
 
                require: ["slider-value-range"],
2328
 
                ignoreRegistered: true,
2329
 
                allowRollup: false
2330
 
            });
2331
 
            loader.calculate();
2332
 
            //Testing A normal module
2333
 
            Assert.isTrue((loader.sorted.indexOf("slider-value-range")) > -1, "Module (slider-value-range) not found in sorted array");
2334
 
        },
2335
 
     "Testing sortable": function(data) {
2336
 
            var loader = new Y.Loader({
2337
 
                require: ["sortable"],
2338
 
                ignoreRegistered: true,
2339
 
                allowRollup: false
2340
 
            });
2341
 
            loader.calculate();
2342
 
            //Testing A normal module
2343
 
            Assert.isTrue((loader.sorted.indexOf("sortable")) > -1, "Module (sortable) not found in sorted array");
2344
 
        },
2345
 
     "Testing sortable-scroll": function(data) {
2346
 
            var loader = new Y.Loader({
2347
 
                require: ["sortable-scroll"],
2348
 
                ignoreRegistered: true,
2349
 
                allowRollup: false
2350
 
            });
2351
 
            loader.calculate();
2352
 
            //Testing A normal module
2353
 
            Assert.isTrue((loader.sorted.indexOf("sortable-scroll")) > -1, "Module (sortable-scroll) not found in sorted array");
2354
 
        },
2355
 
     "Testing stylesheet": function(data) {
2356
 
            var loader = new Y.Loader({
2357
 
                require: ["stylesheet"],
2358
 
                ignoreRegistered: true,
2359
 
                allowRollup: false
2360
 
            });
2361
 
            loader.calculate();
2362
 
            //Testing A normal module
2363
 
            Assert.isTrue((loader.sorted.indexOf("stylesheet")) > -1, "Module (stylesheet) not found in sorted array");
2364
 
        },
2365
 
     "Testing substitute": function(data) {
2366
 
            var loader = new Y.Loader({
2367
 
                require: ["substitute"],
2368
 
                ignoreRegistered: true,
2369
 
                allowRollup: false
2370
 
            });
2371
 
            loader.calculate();
2372
 
            //Testing A normal module
2373
 
            Assert.isTrue((loader.sorted.indexOf("substitute")) > -1, "Module (substitute) not found in sorted array");
2374
 
        },
2375
 
     "Testing swf": function(data) {
2376
 
            var loader = new Y.Loader({
2377
 
                require: ["swf"],
2378
 
                ignoreRegistered: true,
2379
 
                allowRollup: false
2380
 
            });
2381
 
            loader.calculate();
2382
 
            //Testing A normal module
2383
 
            Assert.isTrue((loader.sorted.indexOf("swf")) > -1, "Module (swf) not found in sorted array");
2384
 
        },
2385
 
     "Testing swfdetect": function(data) {
2386
 
            var loader = new Y.Loader({
2387
 
                require: ["swfdetect"],
2388
 
                ignoreRegistered: true,
2389
 
                allowRollup: false
2390
 
            });
2391
 
            loader.calculate();
2392
 
            //Testing A normal module
2393
 
            Assert.isTrue((loader.sorted.indexOf("swfdetect")) > -1, "Module (swfdetect) not found in sorted array");
2394
 
        },
2395
 
     "Testing tabview": function(data) {
2396
 
            var loader = new Y.Loader({
2397
 
                require: ["tabview"],
2398
 
                ignoreRegistered: true,
2399
 
                allowRollup: false
2400
 
            });
2401
 
            loader.calculate();
2402
 
            //Testing A normal module
2403
 
            Assert.isTrue((loader.sorted.indexOf("tabview")) > -1, "Module (tabview) not found in sorted array");
2404
 
        },
2405
 
     "Testing tabview-base": function(data) {
2406
 
            var loader = new Y.Loader({
2407
 
                require: ["tabview-base"],
2408
 
                ignoreRegistered: true,
2409
 
                allowRollup: false
2410
 
            });
2411
 
            loader.calculate();
2412
 
            //Testing A normal module
2413
 
            Assert.isTrue((loader.sorted.indexOf("tabview-base")) > -1, "Module (tabview-base) not found in sorted array");
2414
 
        },
2415
 
     "Testing tabview-plugin": function(data) {
2416
 
            var loader = new Y.Loader({
2417
 
                require: ["tabview-plugin"],
2418
 
                ignoreRegistered: true,
2419
 
                allowRollup: false
2420
 
            });
2421
 
            loader.calculate();
2422
 
            //Testing A normal module
2423
 
            Assert.isTrue((loader.sorted.indexOf("tabview-plugin")) > -1, "Module (tabview-plugin) not found in sorted array");
2424
 
        },
2425
 
     "Testing test": function(data) {
2426
 
            var loader = new Y.Loader({
2427
 
                require: ["test"],
2428
 
                ignoreRegistered: true,
2429
 
                allowRollup: false
2430
 
            });
2431
 
            loader.calculate();
2432
 
            //Testing A normal module
2433
 
            Assert.isTrue((loader.sorted.indexOf("test")) > -1, "Module (test) not found in sorted array");
2434
 
        },
2435
 
     "Testing text": function(data) {
2436
 
            var loader = new Y.Loader({
2437
 
                require: ["text"],
2438
 
                ignoreRegistered: true,
2439
 
                allowRollup: false
2440
 
            });
2441
 
            loader.calculate();
2442
 
            //Testing A rollup module
2443
 
            Assert.isTrue((loader.sorted.indexOf("text-accentfold")) > -1, "Module (text-accentfold) not found in sorted array");
2444
 
            Assert.isTrue((loader.sorted.indexOf("text-wordbreak")) > -1, "Module (text-wordbreak) not found in sorted array");
2445
 
        },
2446
 
     "Testing text-accentfold": function(data) {
2447
 
            var loader = new Y.Loader({
2448
 
                require: ["text-accentfold"],
2449
 
                ignoreRegistered: true,
2450
 
                allowRollup: false
2451
 
            });
2452
 
            loader.calculate();
2453
 
            //Testing A normal module
2454
 
            Assert.isTrue((loader.sorted.indexOf("text-accentfold")) > -1, "Module (text-accentfold) not found in sorted array");
2455
 
        },
2456
 
     "Testing text-data-accentfold": function(data) {
2457
 
            var loader = new Y.Loader({
2458
 
                require: ["text-data-accentfold"],
2459
 
                ignoreRegistered: true,
2460
 
                allowRollup: false
2461
 
            });
2462
 
            loader.calculate();
2463
 
            //Testing A normal module
2464
 
            Assert.isTrue((loader.sorted.indexOf("text-data-accentfold")) > -1, "Module (text-data-accentfold) not found in sorted array");
2465
 
        },
2466
 
     "Testing text-data-wordbreak": function(data) {
2467
 
            var loader = new Y.Loader({
2468
 
                require: ["text-data-wordbreak"],
2469
 
                ignoreRegistered: true,
2470
 
                allowRollup: false
2471
 
            });
2472
 
            loader.calculate();
2473
 
            //Testing A normal module
2474
 
            Assert.isTrue((loader.sorted.indexOf("text-data-wordbreak")) > -1, "Module (text-data-wordbreak) not found in sorted array");
2475
 
        },
2476
 
     "Testing text-wordbreak": function(data) {
2477
 
            var loader = new Y.Loader({
2478
 
                require: ["text-wordbreak"],
2479
 
                ignoreRegistered: true,
2480
 
                allowRollup: false
2481
 
            });
2482
 
            loader.calculate();
2483
 
            //Testing A normal module
2484
 
            Assert.isTrue((loader.sorted.indexOf("text-wordbreak")) > -1, "Module (text-wordbreak) not found in sorted array");
2485
 
        },
2486
 
     "Testing transition": function(data) {
2487
 
            var loader = new Y.Loader({
2488
 
                require: ["transition"],
2489
 
                ignoreRegistered: true,
2490
 
                allowRollup: false
2491
 
            });
2492
 
            loader.calculate();
2493
 
            //Testing A normal module
2494
 
            Assert.isTrue((loader.sorted.indexOf("transition")) > -1, "Module (transition) not found in sorted array");
2495
 
        },
2496
 
     "Testing transition-timer": function(data) {
2497
 
            var loader = new Y.Loader({
2498
 
                require: ["transition-timer"],
2499
 
                ignoreRegistered: true,
2500
 
                allowRollup: false
2501
 
            });
2502
 
            loader.calculate();
2503
 
            //Testing A normal module
2504
 
            Assert.isTrue((loader.sorted.indexOf("transition-timer")) > -1, "Module (transition-timer) not found in sorted array");
2505
 
        },
2506
 
     "Testing uploader": function(data) {
2507
 
            var loader = new Y.Loader({
2508
 
                require: ["uploader"],
2509
 
                ignoreRegistered: true,
2510
 
                allowRollup: false
2511
 
            });
2512
 
            loader.calculate();
2513
 
            //Testing A normal module
2514
 
            Assert.isTrue((loader.sorted.indexOf("uploader")) > -1, "Module (uploader) not found in sorted array");
2515
 
        },
2516
 
     "Testing view": function(data) {
2517
 
            var loader = new Y.Loader({
2518
 
                require: ["view"],
2519
 
                ignoreRegistered: true,
2520
 
                allowRollup: false
2521
 
            });
2522
 
            loader.calculate();
2523
 
            //Testing A normal module
2524
 
            Assert.isTrue((loader.sorted.indexOf("view")) > -1, "Module (view) not found in sorted array");
2525
 
        },
2526
 
     "Testing widget": function(data) {
2527
 
            var loader = new Y.Loader({
2528
 
                require: ["widget"],
2529
 
                ignoreRegistered: true,
2530
 
                allowRollup: false
2531
 
            });
2532
 
            loader.calculate();
2533
 
            //Testing A rollup module
2534
 
            Assert.isTrue((loader.sorted.indexOf("widget-base")) > -1, "Module (widget-base) not found in sorted array");
2535
 
            Assert.isTrue((loader.sorted.indexOf("widget-htmlparser")) > -1, "Module (widget-htmlparser) not found in sorted array");
2536
 
            Assert.isTrue((loader.sorted.indexOf("widget-uievents")) > -1, "Module (widget-uievents) not found in sorted array");
2537
 
            Assert.isTrue((loader.sorted.indexOf("widget-skin")) > -1, "Module (widget-skin) not found in sorted array");
2538
 
        },
2539
 
     "Testing widget-anim": function(data) {
2540
 
            var loader = new Y.Loader({
2541
 
                require: ["widget-anim"],
2542
 
                ignoreRegistered: true,
2543
 
                allowRollup: false
2544
 
            });
2545
 
            loader.calculate();
2546
 
            //Testing A normal module
2547
 
            Assert.isTrue((loader.sorted.indexOf("widget-anim")) > -1, "Module (widget-anim) not found in sorted array");
2548
 
        },
2549
 
     "Testing widget-autohide": function(data) {
2550
 
            var loader = new Y.Loader({
2551
 
                require: ["widget-autohide"],
2552
 
                ignoreRegistered: true,
2553
 
                allowRollup: false
2554
 
            });
2555
 
            loader.calculate();
2556
 
            //Testing A normal module
2557
 
            Assert.isTrue((loader.sorted.indexOf("widget-autohide")) > -1, "Module (widget-autohide) not found in sorted array");
2558
 
        },
2559
 
     "Testing widget-base": function(data) {
2560
 
            var loader = new Y.Loader({
2561
 
                require: ["widget-base"],
2562
 
                ignoreRegistered: true,
2563
 
                allowRollup: false
2564
 
            });
2565
 
            loader.calculate();
2566
 
            //Testing A normal module
2567
 
            Assert.isTrue((loader.sorted.indexOf("widget-base")) > -1, "Module (widget-base) not found in sorted array");
2568
 
        },
2569
 
     "Testing widget-base-ie": function(data) {
2570
 
            var loader = new Y.Loader({
2571
 
                require: ["widget-base-ie"],
2572
 
                ignoreRegistered: true,
2573
 
                allowRollup: false
2574
 
            });
2575
 
            loader.calculate();
2576
 
            //Testing A normal module
2577
 
            Assert.isTrue((loader.sorted.indexOf("widget-base-ie")) > -1, "Module (widget-base-ie) not found in sorted array");
2578
 
        },
2579
 
     "Testing widget-buttons": function(data) {
2580
 
            var loader = new Y.Loader({
2581
 
                require: ["widget-buttons"],
2582
 
                ignoreRegistered: true,
2583
 
                allowRollup: false
2584
 
            });
2585
 
            loader.calculate();
2586
 
            //Testing A normal module
2587
 
            Assert.isTrue((loader.sorted.indexOf("widget-buttons")) > -1, "Module (widget-buttons) not found in sorted array");
2588
 
        },
2589
 
     "Testing widget-child": function(data) {
2590
 
            var loader = new Y.Loader({
2591
 
                require: ["widget-child"],
2592
 
                ignoreRegistered: true,
2593
 
                allowRollup: false
2594
 
            });
2595
 
            loader.calculate();
2596
 
            //Testing A normal module
2597
 
            Assert.isTrue((loader.sorted.indexOf("widget-child")) > -1, "Module (widget-child) not found in sorted array");
2598
 
        },
2599
 
     "Testing widget-htmlparser": function(data) {
2600
 
            var loader = new Y.Loader({
2601
 
                require: ["widget-htmlparser"],
2602
 
                ignoreRegistered: true,
2603
 
                allowRollup: false
2604
 
            });
2605
 
            loader.calculate();
2606
 
            //Testing A normal module
2607
 
            Assert.isTrue((loader.sorted.indexOf("widget-htmlparser")) > -1, "Module (widget-htmlparser) not found in sorted array");
2608
 
        },
2609
 
     "Testing widget-locale": function(data) {
2610
 
            var loader = new Y.Loader({
2611
 
                require: ["widget-locale"],
2612
 
                ignoreRegistered: true,
2613
 
                allowRollup: false
2614
 
            });
2615
 
            loader.calculate();
2616
 
            //Testing A normal module
2617
 
            Assert.isTrue((loader.sorted.indexOf("widget-locale")) > -1, "Module (widget-locale) not found in sorted array");
2618
 
        },
2619
 
     "Testing widget-modality": function(data) {
2620
 
            var loader = new Y.Loader({
2621
 
                require: ["widget-modality"],
2622
 
                ignoreRegistered: true,
2623
 
                allowRollup: false
2624
 
            });
2625
 
            loader.calculate();
2626
 
            //Testing A normal module
2627
 
            Assert.isTrue((loader.sorted.indexOf("widget-modality")) > -1, "Module (widget-modality) not found in sorted array");
2628
 
        },
2629
 
     "Testing widget-parent": function(data) {
2630
 
            var loader = new Y.Loader({
2631
 
                require: ["widget-parent"],
2632
 
                ignoreRegistered: true,
2633
 
                allowRollup: false
2634
 
            });
2635
 
            loader.calculate();
2636
 
            //Testing A normal module
2637
 
            Assert.isTrue((loader.sorted.indexOf("widget-parent")) > -1, "Module (widget-parent) not found in sorted array");
2638
 
        },
2639
 
     "Testing widget-position": function(data) {
2640
 
            var loader = new Y.Loader({
2641
 
                require: ["widget-position"],
2642
 
                ignoreRegistered: true,
2643
 
                allowRollup: false
2644
 
            });
2645
 
            loader.calculate();
2646
 
            //Testing A normal module
2647
 
            Assert.isTrue((loader.sorted.indexOf("widget-position")) > -1, "Module (widget-position) not found in sorted array");
2648
 
        },
2649
 
     "Testing widget-position-align": function(data) {
2650
 
            var loader = new Y.Loader({
2651
 
                require: ["widget-position-align"],
2652
 
                ignoreRegistered: true,
2653
 
                allowRollup: false
2654
 
            });
2655
 
            loader.calculate();
2656
 
            //Testing A normal module
2657
 
            Assert.isTrue((loader.sorted.indexOf("widget-position-align")) > -1, "Module (widget-position-align) not found in sorted array");
2658
 
        },
2659
 
     "Testing widget-position-constrain": function(data) {
2660
 
            var loader = new Y.Loader({
2661
 
                require: ["widget-position-constrain"],
2662
 
                ignoreRegistered: true,
2663
 
                allowRollup: false
2664
 
            });
2665
 
            loader.calculate();
2666
 
            //Testing A normal module
2667
 
            Assert.isTrue((loader.sorted.indexOf("widget-position-constrain")) > -1, "Module (widget-position-constrain) not found in sorted array");
2668
 
        },
2669
 
     "Testing widget-skin": function(data) {
2670
 
            var loader = new Y.Loader({
2671
 
                require: ["widget-skin"],
2672
 
                ignoreRegistered: true,
2673
 
                allowRollup: false
2674
 
            });
2675
 
            loader.calculate();
2676
 
            //Testing A normal module
2677
 
            Assert.isTrue((loader.sorted.indexOf("widget-skin")) > -1, "Module (widget-skin) not found in sorted array");
2678
 
        },
2679
 
     "Testing widget-stack": function(data) {
2680
 
            var loader = new Y.Loader({
2681
 
                require: ["widget-stack"],
2682
 
                ignoreRegistered: true,
2683
 
                allowRollup: false
2684
 
            });
2685
 
            loader.calculate();
2686
 
            //Testing A normal module
2687
 
            Assert.isTrue((loader.sorted.indexOf("widget-stack")) > -1, "Module (widget-stack) not found in sorted array");
2688
 
        },
2689
 
     "Testing widget-stdmod": function(data) {
2690
 
            var loader = new Y.Loader({
2691
 
                require: ["widget-stdmod"],
2692
 
                ignoreRegistered: true,
2693
 
                allowRollup: false
2694
 
            });
2695
 
            loader.calculate();
2696
 
            //Testing A normal module
2697
 
            Assert.isTrue((loader.sorted.indexOf("widget-stdmod")) > -1, "Module (widget-stdmod) not found in sorted array");
2698
 
        },
2699
 
     "Testing widget-uievents": function(data) {
2700
 
            var loader = new Y.Loader({
2701
 
                require: ["widget-uievents"],
2702
 
                ignoreRegistered: true,
2703
 
                allowRollup: false
2704
 
            });
2705
 
            loader.calculate();
2706
 
            //Testing A normal module
2707
 
            Assert.isTrue((loader.sorted.indexOf("widget-uievents")) > -1, "Module (widget-uievents) not found in sorted array");
2708
 
        },
2709
 
     "Testing yql": function(data) {
2710
 
            var loader = new Y.Loader({
2711
 
                require: ["yql"],
2712
 
                ignoreRegistered: true,
2713
 
                allowRollup: false
2714
 
            });
2715
 
            loader.calculate();
2716
 
            //Testing A normal module
2717
 
            Assert.isTrue((loader.sorted.indexOf("yql")) > -1, "Module (yql) not found in sorted array");
2718
 
        }    
2719
 
}));
2720
 
 
2721
 
YUITest.TestRunner.add(suite);