src/core/test/unit/spec/Ext.js

   1 /*
   2
   3 This file is part of Ext JS 4
   4
   5 Copyright (c) 2011 Sencha Inc
   6
   7 Contact:  http://www.sencha.com/contact
   8
   9 GNU General Public License Usage
  10 This file may be used under the terms of the GNU General Public License version 3.0 as published by the Free Software Foundation and appearing in the file LICENSE included in the packaging of this file.  Please review the following information to ensure the GNU General Public License version 3.0 requirements will be met: http://www.gnu.org/copyleft/gpl.html.
  11
  12 If you are unsure which license is appropriate for your use, please contact the sales department at http://www.sencha.com/contact.
  13
  14 */
  15 describe("Ext", function() {
  16
  17     describe("Ext.global", function() {
  18         it("should return the global scope", function() {
  19             expect(Ext.global).toBe((function(){ return this;}).call());
  20         });
  21     });
  22
  23     describe("Ext.apply", function() {
  24         var origin, o;
  25
  26         beforeEach(function() {
  27             origin = {
  28                 name: 'value',
  29                 something: 'cool',
  30                 items: [1,2,3],
  31                 method: function() {
  32                     this.myMethodCalled = true;
  33                 },
  34                 toString: function() {
  35                     this.myToStringCalled = true;
  36                 }
  37             };
  38         });
  39
  40         it("should copy normal properties", function() {
  41             Ext.apply(origin, {
  42                 name: 'newName',
  43                 items: [4,5,6],
  44                 otherThing: 'not cool',
  45                 isCool: false
  46             });
  47
  48             expect(origin.name).toEqual('newName');
  49             expect(origin.items).toEqual([4,5,6]);
  50             expect(origin.something).toEqual('cool');
  51             expect(origin.otherThing).toEqual('not cool');
  52             expect(origin.isCool).toEqual(false);
  53         });
  54
  55         it("should copy functions", function() {
  56             Ext.apply(origin, {
  57                 method: function() {
  58                     this.newMethodCalled = true;
  59                 }
  60             });
  61
  62             origin.method();
  63
  64             expect(origin.myMethodCalled).not.toBeDefined();
  65             expect(origin.newMethodCalled).toBeTruthy();
  66         });
  67
  68         it("should copy non-enumerables", function() {
  69             Ext.apply(origin, {
  70                 toString: function() {
  71                     this.newToStringCalled = true;
  72                 }
  73             });
  74
  75             origin.toString();
  76
  77             expect(origin.myToStringCalled).not.toBeDefined();
  78             expect(origin.newToStringCalled).toBeTruthy();
  79         });
  80
  81         it("should apply properties and return an object", function() {
  82             o = Ext.apply({}, {
  83                 foo: 1,
  84                 bar: 2
  85             });
  86
  87             expect(o).toEqual({
  88                 foo: 1,
  89                 bar: 2
  90             });
  91         });
  92
  93         it("should change the reference of the object", function() {
  94             o = {};
  95             Ext.apply(o, {
  96                 opt1: 'x',
  97                 opt2: 'y'
  98             });
  99
 100             expect(o).toEqual({
 101                 opt1: 'x',
 102                 opt2: 'y'
 103             });
 104         });
 105
 106         it("should overwrite properties", function() {
 107             o = Ext.apply({
 108                 foo: 1,
 109                 baz: 4
 110             }, {
 111                 foo: 2,
 112                 bar: 3
 113             });
 114
 115             expect(o).toEqual({
 116                 foo: 2,
 117                 bar: 3,
 118                 baz: 4
 119             });
 120         });
 121
 122         it("should use default", function() {
 123             o = {};
 124
 125             Ext.apply(o, {
 126                 foo: 'new',
 127                 exist: true
 128             }, {
 129                 foo: 'old',
 130                 def: true
 131             });
 132
 133             expect(o).toEqual({
 134                 foo: 'new',
 135                 def: true,
 136                 exist: true
 137             });
 138         });
 139
 140         it("should override all defaults", function() {
 141             o = Ext.apply({}, {
 142                 foo: 'foo',
 143                 bar: 'bar'
 144             }, {
 145                 foo: 'oldFoo',
 146                 bar: 'oldBar'
 147             });
 148
 149             expect(o).toEqual( {
 150                 foo: 'foo',
 151                 bar: 'bar'
 152             });
 153         });
 154
 155         it("should return null if null is passed as first argument", function() {
 156            expect(Ext.apply(null, {})).toBeNull();
 157         });
 158
 159         it("should return the object if second argument is no defined", function() {
 160             o = {
 161                 foo: 1
 162             };
 163             expect(Ext.apply(o)).toEqual(o);
 164         });
 165
 166         it("should override valueOf", function() {
 167             o = Ext.apply({}, {valueOf: 1});
 168
 169             expect(o.valueOf).toEqual(1);
 170         });
 171
 172         it("should override toString", function() {
 173             o = Ext.apply({}, {toString: 3});
 174
 175             expect(o.toString).toEqual(3);
 176
 177         });
 178     });
 179
 180     describe("Ext.emptyFn", function() {
 181         it("should return undefined without params", function() {
 182             expect(Ext.emptyFn()).toBeUndefined();
 183         });
 184
 185         it("should return undefined if you pass params", function() {
 186            expect(Ext.emptyFn('aaaa', 'bbbbb')).toBeUndefined();
 187         });
 188     });
 189
 190     describe("Ext.iterate", function() {
 191         var itFn;
 192
 193         beforeEach(function() {
 194             itFn = jasmine.createSpy();
 195         });
 196
 197         describe("iterate object", function() {
 198             var o;
 199
 200             beforeEach(function() {
 201                 o = {
 202                     n1: 11,
 203                     n2: 13,
 204                     n3: 18
 205                 };
 206             });
 207
 208             describe("if itFn does not return false", function() {
 209                 beforeEach(function() {
 210                     Ext.iterate(o, itFn);
 211                 });
 212
 213                 it("should call the iterate function 3 times", function () {
 214                     expect(itFn.callCount).toEqual(3);
 215                 });
 216
 217                 it("should call the iterate function with correct arguments", function () {
 218                     expect(itFn.calls[0].args).toEqual(["n1", 11, o]);
 219                     expect(itFn.calls[1].args).toEqual(["n2", 13, o]);
 220                     expect(itFn.calls[2].args).toEqual(["n3", 18, o]);
 221                 });
 222             });
 223
 224             describe("if itFn return false", function() {
 225                 beforeEach(function() {
 226                     itFn.andReturn(false);
 227                     Ext.iterate(o, itFn);
 228                 });
 229
 230                 it("should stop iteration if function return false", function() {
 231                     itFn.andReturn(false);
 232
 233                     expect(itFn.calls.length).toEqual(1);
 234                 });
 235             });
 236         });
 237
 238         describe("do nothing on an empty object", function() {
 239             var o;
 240
 241             beforeEach(function() {
 242                 o = {};
 243                 Ext.iterate(o, itFn);
 244             });
 245
 246             it("should not call the iterate function", function () {
 247                 expect(itFn).not.toHaveBeenCalled();
 248             });
 249
 250         });
 251
 252         describe("iterate array", function() {
 253             var arr;
 254
 255             beforeEach(function() {
 256                 arr = [6, 7, 8, 9];
 257             });
 258
 259             describe("if itFn does not return false", function() {
 260                 beforeEach(function() {
 261                     Ext.iterate(arr, itFn);
 262                 });
 263
 264                 it("should call the iterate function 4 times", function () {
 265                     expect(itFn.callCount).toEqual(4);
 266                 });
 267
 268                 it("should call the iterate function with correct arguments", function () {
 269                     expect(itFn.calls[0].args).toEqual([6, 0, arr]);
 270                     expect(itFn.calls[1].args).toEqual([7, 1, arr]);
 271                     expect(itFn.calls[2].args).toEqual([8, 2, arr]);
 272                     expect(itFn.calls[3].args).toEqual([9, 3, arr]);
 273                 });
 274              });
 275
 276             describe("if itFn return false", function() {
 277                 beforeEach(function() {
 278                     itFn.andReturn(false);
 279                     Ext.iterate(arr, itFn);
 280                 });
 281
 282                 it("should stop iteration if function return false", function() {
 283                     itFn.andReturn(false);
 284
 285                     expect(itFn.calls.length).toEqual(1);
 286                 });
 287             });
 288         });
 289
 290         describe("do nothing on an empty array", function() {
 291             var arr;
 292
 293             beforeEach(function() {
 294                 arr = [];
 295                 Ext.iterate(arr, itFn);
 296             });
 297
 298             it("should not call the iterate function", function () {
 299                 expect(itFn).not.toHaveBeenCalled();
 300             });
 301
 302         });
 303     });
 304
 305     describe("Ext.applyIf", function(){
 306         var o;
 307
 308         it("should apply properties and return an object with an empty destination object", function() {
 309             o = Ext.applyIf({}, {
 310                 foo: 'foo',
 311                 bar: 'bar'
 312             });
 313
 314             expect(o).toEqual( {
 315                 foo: 'foo',
 316                 bar: 'bar'
 317             });
 318         });
 319
 320         it("should not override default properties", function() {
 321             o = Ext.applyIf({
 322                 foo: 'foo'
 323             }, {
 324                 foo: 'oldFoo'
 325             });
 326
 327             expect(o).toEqual({
 328                 foo: 'foo'
 329             });
 330         });
 331
 332         it("should not override default properties with mixing properties", function() {
 333             o = Ext.applyIf({
 334                 foo: 1,
 335                 bar: 2
 336             }, {
 337                 bar: 3,
 338                 baz: 4
 339             });
 340
 341             expect(o).toEqual({
 342                 foo: 1,
 343                 bar: 2,
 344                 baz: 4
 345             });
 346         });
 347
 348           it("should change the reference of the object", function() {
 349             o = {};
 350             Ext.applyIf(o, {
 351                 foo: 2
 352             }, {
 353                 foo: 1
 354             });
 355
 356             expect(o).toEqual({
 357                 foo: 2
 358             });
 359         });
 360
 361         it("should return null if null is passed as first argument", function() {
 362            expect(Ext.applyIf(null, {})).toBeNull();
 363         });
 364
 365         it("should return the object if second argument is no defined", function() {
 366             o = {
 367                 foo: 1
 368             };
 369
 370             expect(Ext.applyIf(o)).toEqual(o);
 371         });
 372     });
 373
 374
 375     describe("Ext.extend", function() {
 376         var Dude, Awesome, david;
 377
 378         beforeEach(function() {
 379             Dude = Ext.extend(Object, {
 380                 constructor: function(config){
 381                     Ext.apply(this, config);
 382                     this.isBadass = false;
 383                 }
 384             });
 385
 386             Awesome = Ext.extend(Dude, {
 387                 constructor: function(){
 388                     Awesome.superclass.constructor.apply(this, arguments);
 389                     this.isBadass = true;
 390                 }
 391             });
 392
 393             david = new Awesome({
 394                 davis: 'isAwesome'
 395             });
 396         });
 397
 398         it("should throw an error if superclass isn't defined", function() {
 399             expect(function() {
 400                 Ext.extend(undefined, {});
 401             }).toRaiseExtError("Attempting to extend from a class which has not been loaded on the page.");
 402         });
 403
 404         it("should create a superclass that return the original classe", function() {
 405             expect(david.superclass).toEqual(Dude.prototype);
 406         });
 407
 408         it("should add override method", function() {
 409             expect(typeof david.override === 'function').toBe(true);
 410         });
 411
 412         it("should override redefined methods", function() {
 413             expect(david.isBadass).toBe(true);
 414         });
 415
 416         it("should keep new properties", function() {
 417             expect(david.davis).toEqual('isAwesome');
 418         });
 419     });
 420
 421     describe("Ext.override", function(){
 422         var Dude,
 423             extApplySpy;
 424
 425         beforeEach(function(){
 426             Dude = function(){}; // avoid to directly override Object class
 427             extApplySpy = spyOn(Ext, "apply");
 428         });
 429
 430         it("should apply override", function(){
 431             var override = {foo: true};
 432
 433             Ext.override(Dude, override);
 434
 435             expect(extApplySpy).toHaveBeenCalledWith(Dude.prototype, override);
 436         });
 437     });
 438
 439     describe("Ext.valueFrom", function() {
 440         var value, defaultValue;
 441
 442         describe("with allowBlank", function() {
 443             describe("and an empty string", function() {
 444                 it("should return the value", function() {
 445                     expect(Ext.valueFrom('', 'aaa', true)).toBe('');
 446                 });
 447             });
 448
 449             describe("and a string", function() {
 450                 it("should return the value", function() {
 451                     expect(Ext.valueFrom('bbb', 'aaa', true)).toBe('bbb');
 452                 });
 453             });
 454
 455             describe("and an undefined value", function() {
 456                 it("should return the default value", function() {
 457                     expect(Ext.valueFrom(undefined, 'aaa', true)).toBe('aaa');
 458                 });
 459             });
 460
 461             describe("and a null value", function() {
 462                 it("should return the default value", function() {
 463                     expect(Ext.valueFrom(null, 'aaa', true)).toBe('aaa');
 464                 });
 465             });
 466
 467             describe("and a 0 value", function() {
 468                 it("should return the value", function() {
 469                     expect(Ext.valueFrom(0, 'aaa', true)).toBe(0);
 470                 });
 471             });
 472         });
 473
 474         describe("without allowBlank", function() {
 475             describe("and an empty string", function() {
 476                 it("should return the default value", function() {
 477                     expect(Ext.valueFrom('', 'aaa')).toBe('aaa');
 478                 });
 479             });
 480
 481             describe("and a string", function() {
 482                 it("should return the value", function() {
 483                     expect(Ext.valueFrom('bbb', 'aaa')).toBe('bbb');
 484                 });
 485             });
 486
 487             describe("and an undefined value", function() {
 488                 it("should return the default value", function() {
 489                     expect(Ext.valueFrom(undefined, 'aaa')).toBe('aaa');
 490                 });
 491             });
 492
 493             describe("and a null value", function() {
 494                 it("should return the default value", function() {
 495                     expect(Ext.valueFrom(null, 'aaa')).toBe('aaa');
 496                 });
 497             });
 498
 499             describe("and a 0 value", function() {
 500                 it("should return the value", function() {
 501                     expect(Ext.valueFrom(0, 'aaa')).toBe(0);
 502                 });
 503             });
 504         });
 505     });
 506
 507     describe("Ext.typeOf", function() {
 508         it("should return null", function() {
 509             expect(Ext.typeOf(null)).toEqual('null');
 510         });
 511         it("should return undefined", function() {
 512             expect(Ext.typeOf(undefined)).toEqual('undefined');
 513         });
 514         it("should return undefined", function() {
 515             expect(Ext.typeOf(window.someWeirdPropertyThatDoesntExist)).toEqual('undefined');
 516         });
 517         it("should return string", function() {
 518             expect(Ext.typeOf('')).toEqual('string');
 519         });
 520         it("should return string", function() {
 521             expect(Ext.typeOf('something')).toEqual('string');
 522         });
 523         it("should return string", function() {
 524             expect(Ext.typeOf('1.2')).toEqual('string');
 525         });
 526         it("should return number", function() {
 527             expect(Ext.typeOf(1)).toEqual('number');
 528         });
 529         it("should return number", function() {
 530             expect(Ext.typeOf(1.2)).toEqual('number');
 531         });
 532         it("should return boolean", function() {
 533             expect(Ext.typeOf(true)).toEqual('boolean');
 534         });
 535         it("should return boolean", function() {
 536             expect(Ext.typeOf(false)).toEqual('boolean');
 537         });
 538         it("should return array", function() {
 539             expect(Ext.typeOf([1,2,3])).toEqual('array');
 540         });
 541         it("should return array", function() {
 542             expect(Ext.typeOf(new Array(1,2,3))).toEqual('array');
 543         });
 544         it("should return function 1", function() {
 545             expect(Ext.typeOf(function(){})).toEqual('function');
 546         });
 547         // Don't run this test in IE
 548         if (typeof alert === 'function') {
 549             it("should return function 2", function() {
 550                 expect(Ext.typeOf(prompt)).toEqual('function');
 551             });
 552         }
 553         it("should return function 3", function() {
 554             expect(Ext.typeOf(new Function())).toEqual('function');
 555         });
 556         it("should return regexp 1", function() {
 557             expect(Ext.typeOf(/test/)).toEqual('regexp');
 558         });
 559         it("should return regexp 2", function() {
 560             expect(Ext.typeOf(new RegExp('test'))).toEqual('regexp');
 561         });
 562         it("should return date", function() {
 563             expect(Ext.typeOf(new Date())).toEqual('date');
 564         });
 565         it("should return textnode", function() {
 566             expect(Ext.typeOf(document.createTextNode('tada'))).toEqual('textnode');
 567         });
 568         it("should return whitespace", function() {
 569             expect(Ext.typeOf(document.createTextNode(' '))).toEqual('whitespace');
 570         });
 571         it("should return whitespace", function() {
 572             expect(Ext.typeOf(document.createTextNode('         '))).toEqual('whitespace');
 573         });
 574         it("should return element", function() {
 575             expect(Ext.typeOf(document.getElementsByTagName('body')[0])).toEqual('element');
 576         });
 577         it("should return element", function() {
 578             expect(Ext.typeOf(document.createElement('button'))).toEqual('element');
 579         });
 580         it("should return element", function() {
 581             expect(Ext.typeOf(new Image())).toEqual('element');
 582         });
 583         it("should return object 1", function() {
 584             expect(Ext.typeOf({some: 'stuff'})).toEqual('object');
 585         });
 586         it("should return object 2", function() {
 587             expect(Ext.typeOf(new Object())).toEqual('object');
 588         });
 589         it("should return object 3", function() {
 590             expect(Ext.typeOf(window)).toEqual('object');
 591         });
 592         it("should return boolean", function() {
 593             expect(Ext.typeOf(new Boolean(true))).toEqual('boolean');
 594         });
 595         it("should return number", function() {
 596             expect(Ext.typeOf(new Number(1.2))).toEqual('number');
 597         });
 598     });
 599
 600     describe("Ext.isIterable", function() {
 601         it("should return true with empty array", function() {
 602             expect(Ext.isIterable([])).toBe(true);
 603         });
 604
 605         it("should return true with filled array", function() {
 606             expect(Ext.isIterable([1, 2, 3, 4])).toBe(true);
 607         });
 608
 609         it("should return false with boolean true", function() {
 610             expect(Ext.isIterable(true)).toBe(false);
 611         });
 612
 613         it("should return false with boolean false", function() {
 614             expect(Ext.isIterable(false)).toBe(false);
 615         });
 616
 617         it("should return false with string", function() {
 618             expect(Ext.isIterable("foo")).toBe(false);
 619         });
 620
 621         it("should return false with empty string", function() {
 622             expect(Ext.isIterable("")).toBe(false);
 623         });
 624
 625         it("should return false with number", function() {
 626             expect(Ext.isIterable(1)).toBe(false);
 627         });
 628
 629         it("should return false with null", function() {
 630             expect(Ext.isIterable(null)).toBe(false);
 631         });
 632
 633         it("should return false with undefined", function() {
 634             expect(Ext.isIterable(undefined)).toBe(false);
 635         });
 636
 637         it("should return false with date", function() {
 638             expect(Ext.isIterable(new Date())).toBe(false);
 639         });
 640
 641         it("should return false with empty object", function() {
 642             expect(Ext.isIterable({})).toBe(false);
 643         });
 644
 645         it("should return true with node list", function() {
 646             expect(Ext.isIterable(document.getElementsByTagName('body'))).toBe(true);
 647         });
 648
 649         it("should return true with html collection", function() {
 650             expect(Ext.isIterable(document.images)).toBe(true);
 651         });
 652     });
 653
 654     describe("Ext.isArray", function() {
 655         it("should return true with empty array", function() {
 656             expect(Ext.isArray([])).toBe(true);
 657         });
 658
 659         it("should return true with filled array", function() {
 660             expect(Ext.isArray([1, 2, 3, 4])).toBe(true);
 661         });
 662
 663         it("should return false with boolean true", function() {
 664             expect(Ext.isArray(true)).toBe(false);
 665         });
 666
 667         it("should return false with boolean false", function() {
 668             expect(Ext.isArray(false)).toBe(false);
 669         });
 670
 671         it("should return false with string", function() {
 672             expect(Ext.isArray("foo")).toBe(false);
 673         });
 674
 675         it("should return false with empty string", function() {
 676             expect(Ext.isArray("")).toBe(false);
 677         });
 678
 679         it("should return false with number", function() {
 680             expect(Ext.isArray(1)).toBe(false);
 681         });
 682
 683         it("should return false with null", function() {
 684             expect(Ext.isArray(null)).toBe(false);
 685         });
 686
 687         it("should return false with undefined", function() {
 688             expect(Ext.isArray(undefined)).toBe(false);
 689         });
 690
 691         it("should return false with date", function() {
 692             expect(Ext.isArray(new Date())).toBe(false);
 693         });
 694
 695         it("should return false with empty object", function() {
 696             expect(Ext.isArray({})).toBe(false);
 697         });
 698
 699         it("should return false with node list", function() {
 700             expect(Ext.isArray(document.getElementsByTagName('body'))).toBe(false);
 701         });
 702
 703         it("should return false with custom class that has a length property", function() {
 704             var C = Ext.extend(Object, {
 705                 length: 1
 706             });
 707             expect(Ext.isArray(new C())).toBe(false);
 708         });
 709
 710         it("should return false with element", function() {
 711            expect(Ext.isArray(Ext.getBody().dom)).toBe(false);
 712         });
 713     });
 714
 715     describe("Ext.isBoolean", function() {
 716         it("should return false with empty array", function() {
 717             expect(Ext.isBoolean([])).toBe(false);
 718         });
 719
 720         it("should return false with filled array", function() {
 721             expect(Ext.isBoolean([1, 2, 3, 4])).toBe(false);
 722         });
 723
 724         it("should return true with boolean true", function() {
 725             expect(Ext.isBoolean(true)).toBe(true);
 726         });
 727
 728         it("should return true with boolean false", function() {
 729             expect(Ext.isBoolean(false)).toBe(true);
 730         });
 731
 732         it("should return false with string", function() {
 733             expect(Ext.isBoolean("foo")).toBe(false);
 734         });
 735
 736         it("should return false with empty string", function() {
 737             expect(Ext.isBoolean("")).toBe(false);
 738         });
 739
 740         it("should return false with number", function() {
 741             expect(Ext.isBoolean(1)).toBe(false);
 742         });
 743
 744         it("should return false with null", function() {
 745             expect(Ext.isBoolean(null)).toBe(false);
 746         });
 747
 748         it("should return false with undefined", function() {
 749             expect(Ext.isBoolean(undefined)).toBe(false);
 750         });
 751
 752         it("should return false with date", function() {
 753             expect(Ext.isBoolean(new Date())).toBe(false);
 754         });
 755
 756         it("should return false with empty object", function() {
 757             expect(Ext.isBoolean({})).toBe(false);
 758         });
 759
 760         it("should return false with node list", function() {
 761             expect(Ext.isBoolean(document.getElementsByTagName('body'))).toBe(false);
 762         });
 763
 764         it("should return false with element", function() {
 765            expect(Ext.isArray(Ext.getBody().dom)).toBe(false);
 766         });
 767     });
 768
 769     describe("Ext.isDate", function() {
 770         it("should return false with empty array", function() {
 771             expect(Ext.isDate([])).toBe(false);
 772         });
 773
 774         it("should return false with filled array", function() {
 775             expect(Ext.isDate([1, 2, 3, 4])).toBe(false);
 776         });
 777
 778         it("should return false with boolean true", function() {
 779             expect(Ext.isDate(true)).toBe(false);
 780         });
 781
 782         it("should return false with boolean false", function() {
 783             expect(Ext.isDate(false)).toBe(false);
 784         });
 785
 786         it("should return false with string", function() {
 787             expect(Ext.isDate("foo")).toBe(false);
 788         });
 789
 790         it("should return false with empty string", function() {
 791             expect(Ext.isDate("")).toBe(false);
 792         });
 793
 794         it("should return false with number", function() {
 795             expect(Ext.isDate(1)).toBe(false);
 796         });
 797
 798         it("should return false with null", function() {
 799             expect(Ext.isDate(null)).toBe(false);
 800         });
 801
 802         it("should return false with undefined", function() {
 803             expect(Ext.isDate(undefined)).toBe(false);
 804         });
 805
 806         it("should return true with date", function() {
 807             expect(Ext.isDate(new Date())).toBe(true);
 808         });
 809
 810         it("should return false with empty object", function() {
 811             expect(Ext.isDate({})).toBe(false);
 812         });
 813
 814         it("should return false with node list", function() {
 815             expect(Ext.isDate(document.getElementsByTagName('body'))).toBe(false);
 816         });
 817
 818         it("should return false with element", function() {
 819             expect(Ext.isDate(Ext.getBody().dom)).toBe(false);
 820         });
 821     });
 822
 823     describe("Ext.isDefined", function() {
 824         it("should return true with empty array", function() {
 825             expect(Ext.isDefined([])).toBe(true);
 826         });
 827
 828         it("should return true with filled array", function() {
 829             expect(Ext.isDefined([1, 2, 3, 4])).toBe(true);
 830         });
 831
 832         it("should return true with boolean true", function() {
 833             expect(Ext.isDefined(true)).toBe(true);
 834         });
 835
 836         it("should return true with boolean false", function() {
 837             expect(Ext.isDefined(false)).toBe(true);
 838         });
 839
 840         it("should return true with string", function() {
 841             expect(Ext.isDefined("foo")).toBe(true);
 842         });
 843
 844         it("should return true with empty string", function() {
 845             expect(Ext.isDefined("")).toBe(true);
 846         });
 847
 848         it("should return true with number", function() {
 849             expect(Ext.isDefined(1)).toBe(true);
 850         });
 851
 852         it("should return true with null", function() {
 853             expect(Ext.isDefined(null)).toBe(true);
 854         });
 855
 856         it("should return false with undefined", function() {
 857             expect(Ext.isDefined(undefined)).toBe(false);
 858         });
 859
 860         it("should return true with date", function() {
 861             expect(Ext.isDefined(new Date())).toBe(true);
 862         });
 863
 864         it("should return true with empty object", function() {
 865             expect(Ext.isDefined({})).toBe(true);
 866         });
 867
 868         it("should return true with node list", function() {
 869             expect(Ext.isDefined(document.getElementsByTagName('body'))).toBe(true);
 870         });
 871
 872         it("should return true with element", function() {
 873            expect(Ext.isDefined(Ext.getBody().dom)).toBe(true);
 874         });
 875     });
 876
 877     describe("Ext.isElement", function() {
 878         it("should return false with empty array", function() {
 879             expect(Ext.isElement([])).toBe(false);
 880         });
 881
 882         it("should return false with filled array", function() {
 883             expect(Ext.isElement([1, 2, 3, 4])).toBe(false);
 884         });
 885
 886         it("should return false with boolean true", function() {
 887             expect(Ext.isElement(true)).toBe(false);
 888         });
 889
 890         it("should return false with boolean false", function() {
 891             expect(Ext.isElement(false)).toBe(false);
 892         });
 893
 894         it("should return false with string", function() {
 895             expect(Ext.isElement("foo")).toBe(false);
 896         });
 897
 898         it("should return false with empty string", function() {
 899             expect(Ext.isElement("")).toBe(false);
 900         });
 901
 902         it("should return false with number", function() {
 903             expect(Ext.isElement(1)).toBe(false);
 904         });
 905
 906         it("should return false with null", function() {
 907             expect(Ext.isElement(null)).toBe(false);
 908         });
 909
 910         it("should return false with undefined", function() {
 911             expect(Ext.isElement(undefined)).toBe(false);
 912         });
 913
 914         it("should return false with date", function() {
 915             expect(Ext.isElement(new Date())).toBe(false);
 916         });
 917
 918         it("should return false with empty object", function() {
 919             expect(Ext.isElement({})).toBe(false);
 920         });
 921
 922         it("should return false with node list", function() {
 923             expect(Ext.isElement(document.getElementsByTagName('body'))).toBe(false);
 924         });
 925
 926         it("should return true with element", function() {
 927            expect(Ext.isElement(Ext.getBody().dom)).toBe(true);
 928         });
 929
 930         it("should return false with Ext.Element", function() {
 931            expect(Ext.isElement(Ext.getBody())).toBe(false);
 932         });
 933
 934         it("should return false with TextNode", function() {
 935             var textNode = document.createTextNode('foobar');
 936             document.body.appendChild(textNode);
 937             expect(Ext.isElement(textNode)).toBe(false);
 938             document.body.removeChild(textNode);
 939         });
 940     });
 941
 942     describe("Ext.isEmpty", function() {
 943         it("should return true with empty array", function() {
 944             expect(Ext.isEmpty([])).toBe(true);
 945         });
 946
 947         it("should return false with filled array", function() {
 948             expect(Ext.isEmpty([1, 2, 3, 4])).toBe(false);
 949         });
 950
 951         it("should return false with boolean true", function() {
 952             expect(Ext.isEmpty(true)).toBe(false);
 953         });
 954
 955         it("should return false with boolean false", function() {
 956             expect(Ext.isEmpty(false)).toBe(false);
 957         });
 958
 959         it("should return false with string", function() {
 960             expect(Ext.isEmpty("foo")).toBe(false);
 961         });
 962
 963         it("should return true with empty string", function() {
 964             expect(Ext.isEmpty("")).toBe(true);
 965         });
 966
 967         it("should return true with empty string with allowBlank", function() {
 968             expect(Ext.isEmpty("", true)).toBe(false);
 969         });
 970
 971         it("should return false with number", function() {
 972             expect(Ext.isEmpty(1)).toBe(false);
 973         });
 974
 975         it("should return true with null", function() {
 976             expect(Ext.isEmpty(null)).toBe(true);
 977         });
 978
 979         it("should return true with undefined", function() {
 980             expect(Ext.isEmpty(undefined)).toBe(true);
 981         });
 982
 983         it("should return false with date", function() {
 984             expect(Ext.isEmpty(new Date())).toBe(false);
 985         });
 986
 987         it("should return false with empty object", function() {
 988             expect(Ext.isEmpty({})).toBe(false);
 989         });
 990     });
 991
 992     describe("Ext.isFunction", function() {
 993         beforeEach(function() {
 994             // add global variable in whitelist
 995             addGlobal("ExtBox1");
 996         });
 997
 998         it("should return true with anonymous function", function() {
 999             expect(Ext.isFunction(function(){})).toBe(true);
1000         });
1001
1002         it("should return true with new Function syntax", function() {
1003             expect(Ext.isFunction(Ext.functionFactory('return "";'))).toBe(true);
1004         });
1005
1006         it("should return true with static function", function() {
1007             expect(Ext.isFunction(Ext.emptyFn)).toBe(true);
1008         });
1009
1010         it("should return true with instance function", function() {
1011             var stupidClass = function() {},
1012                 testObject;
1013             stupidClass.prototype.testMe = function() {};
1014             testObject = new stupidClass();
1015
1016             expect(Ext.isFunction(testObject.testMe)).toBe(true);
1017         });
1018
1019         it("should return true with function on object", function() {
1020             var o = {
1021                 fn: function() {
1022                 }
1023             };
1024
1025             expect(Ext.isFunction(o.fn)).toBe(true);
1026         });
1027
1028         it("should return false with empty array", function() {
1029             expect(Ext.isFunction([])).toBe(false);
1030         });
1031
1032         it("should return false with filled array", function() {
1033             expect(Ext.isFunction([1, 2, 3, 4])).toBe(false);
1034         });
1035
1036         it("should return false with boolean true", function() {
1037             expect(Ext.isFunction(true)).toBe(false);
1038         });
1039
1040         it("should return false with boolean false", function() {
1041             expect(Ext.isFunction(false)).toBe(false);
1042         });
1043
1044         it("should return false with string", function() {
1045             expect(Ext.isFunction("foo")).toBe(false);
1046         });
1047
1048         it("should return false with empty string", function() {
1049             expect(Ext.isFunction("")).toBe(false);
1050         });
1051
1052         it("should return false with number", function() {
1053             expect(Ext.isFunction(1)).toBe(false);
1054         });
1055
1056         it("should return false with null", function() {
1057             expect(Ext.isFunction(null)).toBe(false);
1058         });
1059
1060         it("should return false with undefined", function() {
1061             expect(Ext.isFunction(undefined)).toBe(false);
1062         });
1063
1064         it("should return false with date", function() {
1065             expect(Ext.isFunction(new Date())).toBe(false);
1066         });
1067
1068         it("should return false with empty object", function() {
1069             expect(Ext.isFunction({})).toBe(false);
1070         });
1071
1072         it("should return false with node list", function() {
1073             expect(Ext.isFunction(document.getElementsByTagName('body'))).toBe(false);
1074         });
1075     });
1076
1077     describe("Ext.isNumber", function() {
1078         it("should return true with zero", function() {
1079             expect(Ext.isNumber(0)).toBe(true);
1080         });
1081
1082         it("should return true with non zero", function() {
1083             expect(Ext.isNumber(4)).toBe(true);
1084         });
1085
1086         it("should return true with negative integer", function() {
1087             expect(Ext.isNumber(-3)).toBe(true);
1088         });
1089
1090         it("should return true with float", function() {
1091             expect(Ext.isNumber(1.75)).toBe(true);
1092         });
1093
1094         it("should return true with negative float", function() {
1095             expect(Ext.isNumber(-4.75)).toBe(true);
1096         });
1097
1098         it("should return true with Number.MAX_VALUE", function() {
1099             expect(Ext.isNumber(Number.MAX_VALUE)).toBe(true);
1100         });
1101
1102         it("should return true with Number.MIN_VALUE", function() {
1103             expect(Ext.isNumber(Number.MIN_VALUE)).toBe(true);
1104         });
1105
1106         it("should return true with Math.PI", function() {
1107             expect(Ext.isNumber(Math.PI)).toBe(true);
1108         });
1109
1110         it("should return true with Number() contructor", function() {
1111             expect(Ext.isNumber(Number('3.1'))).toBe(true);
1112         });
1113
1114         it("should return false with NaN", function() {
1115             expect(Ext.isNumber(Number.NaN)).toBe(false);
1116         });
1117
1118         it("should return false with Number.POSITIVE_INFINITY", function() {
1119             expect(Ext.isNumber(Number.POSITIVE_INFINITY)).toBe(false);
1120         });
1121
1122         it("should return false with Number.NEGATIVE_INFINITY", function() {
1123             expect(Ext.isNumber(Number.NEGATIVE_INFINITY)).toBe(false);
1124         });
1125
1126         it("should return false with empty array", function() {
1127             expect(Ext.isNumber([])).toBe(false);
1128         });
1129
1130         it("should return false with filled array", function() {
1131             expect(Ext.isNumber([1, 2, 3, 4])).toBe(false);
1132         });
1133
1134         it("should return false with boolean true", function() {
1135             expect(Ext.isNumber(true)).toBe(false);
1136         });
1137
1138         it("should return false with boolean false", function() {
1139             expect(Ext.isNumber(false)).toBe(false);
1140         });
1141
1142         it("should return false with string", function() {
1143             expect(Ext.isNumber("foo")).toBe(false);
1144         });
1145
1146         it("should return false with empty string", function() {
1147             expect(Ext.isNumber("")).toBe(false);
1148         });
1149
1150         it("should return false with string containing a number", function() {
1151             expect(Ext.isNumber("1.0")).toBe(false);
1152         });
1153
1154         it("should return false with undefined", function() {
1155             expect(Ext.isNumber(undefined)).toBe(false);
1156         });
1157
1158         it("should return false with date", function() {
1159             expect(Ext.isNumber(new Date())).toBe(false);
1160         });
1161
1162         it("should return false with empty object", function() {
1163             expect(Ext.isNumber({})).toBe(false);
1164         });
1165
1166         it("should return false with node list", function() {
1167             expect(Ext.isNumber(document.getElementsByTagName('body'))).toBe(false);
1168         });
1169     });
1170
1171     describe("Ext.isNumeric", function() {
1172         it("should return true with zero", function() {
1173             expect(Ext.isNumeric(0)).toBe(true);
1174         });
1175
1176         it("should return true with non zero", function() {
1177             expect(Ext.isNumeric(4)).toBe(true);
1178         });
1179
1180         it("should return true with negative integer", function() {
1181             expect(Ext.isNumeric(-3)).toBe(true);
1182         });
1183
1184         it("should return true with float", function() {
1185             expect(Ext.isNumeric(1.75)).toBe(true);
1186         });
1187
1188         it("should return true with negative float", function() {
1189             expect(Ext.isNumeric(-4.75)).toBe(true);
1190         });
1191
1192         it("should return true with Number.MAX_VALUE", function() {
1193             expect(Ext.isNumeric(Number.MAX_VALUE)).toBe(true);
1194         });
1195
1196         it("should return true with Number.MIN_VALUE", function() {
1197             expect(Ext.isNumeric(Number.MIN_VALUE)).toBe(true);
1198         });
1199
1200         it("should return true with Math.PI", function() {
1201             expect(Ext.isNumeric(Math.PI)).toBe(true);
1202         });
1203
1204         it("should return true with Number() contructor", function() {
1205             expect(Ext.isNumeric(Number('3.1'))).toBe(true);
1206         });
1207
1208         it("should return false with NaN", function() {
1209             expect(Ext.isNumeric(Number.NaN)).toBe(false);
1210         });
1211
1212         it("should return false with Number.POSITIVE_INFINITY", function() {
1213             expect(Ext.isNumeric(Number.POSITIVE_INFINITY)).toBe(false);
1214         });
1215
1216         it("should return false with Number.NEGATIVE_INFINITY", function() {
1217             expect(Ext.isNumeric(Number.NEGATIVE_INFINITY)).toBe(false);
1218         });
1219
1220         it("should return false with empty array", function() {
1221             expect(Ext.isNumeric([])).toBe(false);
1222         });
1223
1224         it("should return false with filled array", function() {
1225             expect(Ext.isNumeric([1, 2, 3, 4])).toBe(false);
1226         });
1227
1228         it("should return false with boolean true", function() {
1229             expect(Ext.isNumeric(true)).toBe(false);
1230         });
1231
1232         it("should return false with boolean false", function() {
1233             expect(Ext.isNumeric(false)).toBe(false);
1234         });
1235
1236         it("should return false with string", function() {
1237             expect(Ext.isNumeric("foo")).toBe(false);
1238         });
1239
1240         it("should return false with empty string", function() {
1241             expect(Ext.isNumeric("")).toBe(false);
1242         });
1243
1244         it("should return true with string containing a number", function() {
1245             expect(Ext.isNumeric("1.0")).toBe(true);
1246         });
1247
1248         it("should return false with undefined", function() {
1249             expect(Ext.isNumeric(undefined)).toBe(false);
1250         });
1251
1252         it("should return false with date", function() {
1253             expect(Ext.isNumeric(new Date())).toBe(false);
1254         });
1255
1256         it("should return false with empty object", function() {
1257             expect(Ext.isNumeric({})).toBe(false);
1258         });
1259
1260         it("should return false with node list", function() {
1261             expect(Ext.isNumeric(document.getElementsByTagName('body'))).toBe(false);
1262         });
1263     });
1264
1265     describe("Ext.isObject", function() {
1266         it("should return false with empty array", function() {
1267             expect(Ext.isObject([])).toBe(false);
1268         });
1269
1270         it("should return false with filled array", function() {
1271             expect(Ext.isObject([1, 2, 3, 4])).toBe(false);
1272         });
1273
1274         it("should return false with boolean true", function() {
1275             expect(Ext.isObject(true)).toBe(false);
1276         });
1277
1278         it("should return false with boolean false", function() {
1279             expect(Ext.isObject(false)).toBe(false);
1280         });
1281
1282         it("should return false with string", function() {
1283             expect(Ext.isObject("foo")).toBe(false);
1284         });
1285
1286         it("should return false with empty string", function() {
1287             expect(Ext.isObject("")).toBe(false);
1288         });
1289
1290         it("should return false with number", function() {
1291             expect(Ext.isObject(1)).toBe(false);
1292         });
1293
1294         it("should return false with null", function() {
1295             expect(Ext.isObject(null)).toBe(false);
1296         });
1297
1298         it("should return false with undefined", function() {
1299             expect(Ext.isObject(undefined)).toBe(false);
1300         });
1301
1302         it("should return false with date", function() {
1303             expect(Ext.isObject(new Date())).toBe(false);
1304         });
1305
1306         it("should return true with empty object", function() {
1307             expect(Ext.isObject({})).toBe(true);
1308         });
1309
1310         it("should return false with a DOM node", function() {
1311             expect(Ext.isObject(document.body)).toBe(false);
1312         });
1313
1314         it("should return false with a Text node", function() {
1315             expect(Ext.isObject(document.createTextNode('test'))).toBe(false);
1316         });
1317
1318         it("should return true with object with properties", function() {
1319             expect(Ext.isObject({
1320                 foo: 1
1321             })).toBe(true);
1322         });
1323
1324         it("should return true with object instance", function() {
1325             var stupidClass = function() {};
1326
1327             expect(Ext.isObject(new stupidClass())).toBe(true);
1328         });
1329
1330         it("should return true with new Object syntax", function() {
1331             expect(Ext.isObject(new Object())).toBe(true);
1332         });
1333
1334         it("should return false with dom element", function() {
1335             expect(Ext.isObject(document.body)).toBe(false);
1336         });
1337     });
1338
1339     describe("Ext.isPrimitive", function() {
1340         it("should return true with integer", function() {
1341             expect(Ext.isPrimitive(1)).toBe(true);
1342         });
1343
1344         it("should return true with negative integer", function() {
1345             expect(Ext.isPrimitive(-21)).toBe(true);
1346         });
1347
1348         it("should return true with float", function() {
1349             expect(Ext.isPrimitive(2.1)).toBe(true);
1350         });
1351
1352         it("should return true with negative float", function() {
1353             expect(Ext.isPrimitive(-12.1)).toBe(true);
1354         });
1355
1356         it("should return true with Number.MAX_VALUE", function() {
1357             expect(Ext.isPrimitive(Number.MAX_VALUE)).toBe(true);
1358         });
1359
1360         it("should return true with Math.PI", function() {
1361             expect(Ext.isPrimitive(Math.PI)).toBe(true);
1362         });
1363
1364         it("should return true with empty string", function() {
1365             expect(Ext.isPrimitive("")).toBe(true);
1366         });
1367
1368         it("should return true with non empty string", function() {
1369             expect(Ext.isPrimitive("foo")).toBe(true);
1370         });
1371
1372         it("should return true with boolean true", function() {
1373             expect(Ext.isPrimitive(true)).toBe(true);
1374         });
1375
1376         it("should return true with boolean false", function() {
1377             expect(Ext.isPrimitive(false)).toBe(true);
1378         });
1379
1380         it("should return false with null", function() {
1381             expect(Ext.isPrimitive(null)).toBe(false);
1382         });
1383
1384         it("should return false with undefined", function() {
1385             expect(Ext.isPrimitive(undefined)).toBe(false);
1386         });
1387
1388         it("should return false with object", function() {
1389             expect(Ext.isPrimitive({})).toBe(false);
1390         });
1391
1392         it("should return false with object instance", function() {
1393             var stupidClass = function() {};
1394             expect(Ext.isPrimitive(new stupidClass())).toBe(false);
1395         });
1396
1397         it("should return false with array", function() {
1398             expect(Ext.isPrimitive([])).toBe(false);
1399         });
1400     });
1401
1402     describe("Ext.isString", function() {
1403         it("should return true with empty string", function() {
1404             expect(Ext.isString("")).toBe(true);
1405         });
1406
1407         it("should return true with non empty string", function() {
1408             expect(Ext.isString("foo")).toBe(true);
1409         });
1410
1411         it("should return true with String() syntax", function() {
1412             expect(Ext.isString(String(""))).toBe(true);
1413         });
1414
1415         it("should return false with new String() syntax", function() { //should return an object that wraps the primitive
1416             expect(Ext.isString(new String(""))).toBe(false);
1417         });
1418
1419         it("should return false with number", function() {
1420             expect(Ext.isString(1)).toBe(false);
1421         });
1422
1423         it("should return false with boolean", function() {
1424             expect(Ext.isString(true)).toBe(false);
1425         });
1426
1427         it("should return false with null", function() {
1428             expect(Ext.isString(null)).toBe(false);
1429         });
1430
1431         it("should return false with undefined", function() {
1432             expect(Ext.isString(undefined)).toBe(false);
1433         });
1434
1435         it("should return false with array", function() {
1436             expect(Ext.isString([])).toBe(false);
1437         });
1438
1439         it("should return false with object", function() {
1440             expect(Ext.isString({})).toBe(false);
1441         });
1442     });
1443
1444     describe("Ext.isTextNode", function() {
1445         it("should return false with empty array", function() {
1446             expect(Ext.isTextNode([])).toBe(false);
1447         });
1448
1449         it("should return false with filled array", function() {
1450             expect(Ext.isTextNode([1, 2, 3, 4])).toBe(false);
1451         });
1452
1453         it("should return false with boolean true", function() {
1454             expect(Ext.isTextNode(true)).toBe(false);
1455         });
1456
1457         it("should return false with boolean false", function() {
1458             expect(Ext.isTextNode(false)).toBe(false);
1459         });
1460
1461         it("should return false with string", function() {
1462             expect(Ext.isTextNode("foo")).toBe(false);
1463         });
1464
1465         it("should return false with empty string", function() {
1466             expect(Ext.isTextNode("")).toBe(false);
1467         });
1468
1469         it("should return false with number", function() {
1470             expect(Ext.isTextNode(1)).toBe(false);
1471         });
1472
1473         it("should return false with null", function() {
1474             expect(Ext.isTextNode(null)).toBe(false);
1475         });
1476
1477         it("should return false with undefined", function() {
1478             expect(Ext.isTextNode(undefined)).toBe(false);
1479         });
1480
1481         it("should return false with date", function() {
1482             expect(Ext.isTextNode(new Date())).toBe(false);
1483         });
1484
1485         it("should return false with empty object", function() {
1486             expect(Ext.isTextNode({})).toBe(false);
1487         });
1488
1489         it("should return false with node list", function() {
1490             expect(Ext.isTextNode(document.getElementsByTagName('body'))).toBe(false);
1491         });
1492
1493         it("should return false with element", function() {
1494            expect(Ext.isTextNode(Ext.getBody().dom)).toBe(false);
1495         });
1496
1497         it("should return false with Ext.Element", function() {
1498            expect(Ext.isTextNode(Ext.getBody())).toBe(false);
1499         });
1500
1501         it("should return true with TextNode", function() {
1502             var textNode = document.createTextNode('foobar');
1503             document.body.appendChild(textNode);
1504             expect(Ext.isTextNode(textNode)).toBe(true);
1505             document.body.removeChild(textNode);
1506         });
1507     });
1508
1509     describe("Ext.clone", function() {
1510         var clone;
1511
1512         afterEach(function() {
1513             clone = null;
1514         });
1515
1516         it("should clone an array", function() {
1517             var array = [2,'5',[1,3,4]];
1518             clone = Ext.clone(array);
1519             expect(clone).toEqual(array);
1520             expect(clone).not.toBe(array);
1521         });
1522
1523         it("should clone an object", function() {
1524             var object = {
1525                 fn: function() {
1526                     return 1;
1527                 },
1528                 b: 2
1529             };
1530             clone = Ext.clone(object);
1531             expect(clone).toEqual(object);
1532             expect(clone).not.toBe(object);
1533         });
1534
1535         it("should clone a date", function(){
1536             var date = new Date();
1537             clone = Ext.clone(date);
1538             expect(clone).toEqual(date);
1539             expect(clone).not.toBe(date);
1540         });
1541
1542         it("should clone a dom node", function(){
1543             var node = document.createElement('DIV');
1544             document.body.appendChild(node);
1545             clone = Ext.clone(node);
1546             expect(clone.tagName).toEqual(clone.tagName);
1547             expect(clone.innerHTML).toEqual(clone.innerHTML);
1548             expect(clone).not.toBe(node);
1549             document.body.removeChild(node);
1550         });
1551     });
1552
1553     describe('getUniqueGlobalNamespace', function() {
1554         it("should return an unique global namespace", function() {
1555             expect(Ext.getUniqueGlobalNamespace()).toBe("ExtBox1");
1556         });
1557     });
1558 });
1559