extjs-rails 4.1.0.alpha1

data/app/assets/javascripts/extjs-rails/src/core/test/unit/spec/lang/Number.js

@@ -0,0 +1,323 @@
+describe("Ext.Number", function(){
+    var Number = Ext.Number;
+    
+    describe("constraining a number", function(){
+        describe("integers", function(){
+            describe("if the number is within the constaints", function(){
+                it("should leave the number alone if it is equal to the min and the max", function(){
+                    expect(Number.constrain(1, 1, 1)).toEqual(1);
+                });
+                
+                it("should leave the number alone if it is equal to the min", function(){
+                    expect(Number.constrain(1, 1, 5)).toEqual(1);
+                });
+                
+                it("should leave the number alone if it is equal to the max", function(){
+                    expect(Number.constrain(5, 1, 5)).toEqual(5);
+                });
+                
+                it("should leave the number alone if it is within the min and the max", function(){
+                    expect(Number.constrain(3, 1, 5)).toEqual(3);
+                });
+                
+                it("should leave a negative number alone if it is within the min and the max", function(){
+                    expect(Number.constrain(-3, -5, -1)).toEqual(-3);
+                });
+            });
+            
+            describe("if the number is not within the constraints", function(){
+                it("should make the number equal to the min value", function(){
+                    expect(Number.constrain(1, 3, 5)).toEqual(3);
+                });
+                
+                it("should make the number equal to the max value", function(){
+                    expect(Number.constrain(100, 1, 5)).toEqual(5);
+                });
+                
+                describe("and the number is negative", function(){
+                    it("should make the number equal to the min value", function(){
+                        expect(Number.constrain(-10, -50, -30)).toEqual(-30);
+                    });
+                    
+                    it("should make the number equal to the max value", function(){
+                        expect(Number.constrain(-100, -50, -30)).toEqual(-50);
+                    });
+                });
+            });
+
+            describe("constrain NaN", function() {
+                it("should never constrain a NaN between two numbers", function(){
+                    expect(isNaN(Number.constrain(NaN, 3, 5))).toEqual(true);
+                });                
+                it("should never constrain a NaN between zero and undefined", function(){
+                    expect(isNaN(Number.constrain(NaN, 0, undefined))).toEqual(true);
+                });                
+                it("should never constrain a NaN between undefined and zero", function(){
+                    expect(isNaN(Number.constrain(NaN, undefined, 0))).toEqual(true);
+                });                
+                it("should never constrain a NaN between a number and undefined", function(){
+                    expect(isNaN(Number.constrain(NaN, 10, undefined))).toEqual(true);
+                });                
+                it("should never constrain a NaN between undefined and a number", function(){
+                    expect(isNaN(Number.constrain(NaN, undefined, 10))).toEqual(true);
+                });                
+                it("should never constrain a NaN between two undefined values", function(){
+                    expect(isNaN(Number.constrain(NaN, undefined, undefined))).toEqual(true);
+                });                
+            });
+
+            describe("constrain with NaN/undefined max", function() {
+                it("should ignore NaN max", function(){
+                    expect(Number.constrain(2, 1, NaN)).toEqual(2);
+                });                
+                it("should ignore NaN max and limit to min", function(){
+                    expect(Number.constrain(2, 5, NaN)).toEqual(5);
+                });                
+                it("should ignore undefined max", function(){
+                    expect(Number.constrain(2, 1, undefined)).toEqual(2);
+                });                
+                it("should ignore undefined max and limit to min", function(){
+                    expect(Number.constrain(2, 5, undefined)).toEqual(5);
+                });                
+            });
+
+            describe("constrain with NaN/undefined min", function() {
+                it("should ignore NaN min", function(){
+                    expect(Number.constrain(2, NaN, 5)).toEqual(2);
+                });                
+                it("should ignore NaN min and limit to max", function(){
+                    expect(Number.constrain(20, NaN, 5)).toEqual(5);
+                });                
+                it("should ignore undefined min", function(){
+                    expect(Number.constrain(2, undefined, 5)).toEqual(2);
+                });                
+                it("should ignore undefined min and limit to max", function(){
+                    expect(Number.constrain(20, undefined, 5)).toEqual(5);
+                });                
+            });
+
+            describe("constrain with NaN/undefined min/max", function() {
+                it("should ignore NaN min/max", function(){
+                    expect(Number.constrain(2, NaN, NaN)).toEqual(2);
+                });                
+                it("should ignore undefined min/max", function(){
+                    expect(Number.constrain(2, undefined, undefined)).toEqual(2);
+                });                
+                it("should ignore NaN min and undefined max", function(){
+                    expect(Number.constrain(2, NaN, undefined)).toEqual(2);
+                });                
+                it("should ignore undefined min and NaN max", function(){
+                    expect(Number.constrain(2, undefined, NaN)).toEqual(2);
+                });                
+            });
+        });
+        
+        describe("floating point numbers", function(){
+            describe("if the number is within the constaints", function(){
+                it("should leave the number alone", function(){
+                    expect(Number.constrain(3.3, 3.1, 3.5)).toEqual(3.3);
+                });
+                
+                it("should leave a negative number alone", function(){
+                    expect(Number.constrain(-3.3, -3.5, -3.1)).toEqual(-3.3);
+                });
+            });
+            
+            describe("and the number is negative", function(){
+                it("should make the number equal to the min value", function(){
+                    expect(Number.constrain(-3.3, -3.1, -3)).toEqual(-3.1);
+                });
+                
+                it("should make the number equal to the max value", function(){
+                    expect(Number.constrain(-2.1, -3.1, -3)).toEqual(-3);
+                });
+            });
+        });
+    });
+    
+    describe("toFixed", function(){
+        
+        var f = Number.toFixed;
+        
+        it("should return a string", function(){
+            expect(typeof f(1)).toEqual('string');
+        });
+        
+        it("should default precision to 0", function(){
+            expect(f(1.23456)).toEqual('1');
+        });
+        
+        it("should output the correct number of decimal places", function(){
+            expect(f(1, 3)).toEqual('1.000');
+        });
+        
+        it("should round correctly", function(){
+            expect(f(1.9834657, 1)).toEqual('2.0');
+        });
+        
+        it("should round with negative numbers", function(){
+            expect(f(-3.4265, 2)).toEqual('-3.43');
+        });
+    });
+
+    describe("snap", function(){
+
+        // Params are (value, snapincrement, minValue, maxValue)
+        var snap = Number.snap;
+
+        it("should enforce minValue if increment is zero", function(){
+            expect(snap(40, 0, 50, 100)).toEqual(50);
+        });
+
+        it("should enforce maxValue if increment is zero", function(){
+            expect(snap(5000, 0, 0, 100)).toEqual(100);
+        });
+
+        it("should enforce minValue if passed", function(){
+            expect(snap(0, 2, 1, 100)).toEqual(1);
+        });
+
+        it("should not enforce a minimum if no minValue passed", function(){
+            expect(snap(21, 2, undefined, 100)).toEqual(22);
+        });
+
+        it("should enforce maxValue if passed", function(){
+            expect(snap(1000, 2, undefined, 100)).toEqual(100);
+        });
+
+        it("should not enforce a maximum if no maxValue passed", function(){
+            expect(snap(21, 2, undefined, undefined)).toEqual(22);
+        });
+
+        it("should snap to a snap point based upon zero", function(){
+            expect(snap(56, 2, 55, 65)).toEqual(56);
+            expect(snap(100, 2, 55, 66)).toEqual(66);
+        });
+
+        it("should enforce the minValue", function(){
+            expect(snap(20, 2, 55, 65)).toEqual(55);
+        });
+
+        it("should round to the nearest snap point", function(){
+            expect(snap(4, 5, 0, 100)).toEqual(5);
+        });
+        
+        it("should snap negative numbers", function() {
+           expect(snap(-9, 10, -100, 0)).toBe(-10);
+           expect(snap(-1, 10, -100, 0)).toBe(0);
+        });
+
+    });
+
+    describe("snapInRange", function(){
+
+        // Params are (value, snapincrement, minValue, maxValue)
+        var snapInRange = Number.snapInRange;
+
+        it("should enforce minValue if increment is zero", function(){
+            expect(snapInRange(50, 0, 0, 100)).toEqual(50);
+        });
+
+        it("should enforce maxValue if increment is zero", function(){
+            expect(snapInRange(5000, 0, 0, 100)).toEqual(100);
+        });
+
+        it("should enforce minValue if passed", function(){
+            expect(snapInRange(0, 2, 1, 100)).toEqual(1);
+        });
+
+        it("should not enforce a minimum if no minValue passed", function(){
+            expect(snapInRange(21, 2, undefined, 100)).toEqual(22);
+        });
+
+        it("should enforce maxValue if passed", function(){
+            expect(snapInRange(1000, 2, undefined, 100)).toEqual(100);
+        });
+
+        it("should not enforce a maximum if no maxValue passed", function(){
+            expect(snapInRange(21, 2, undefined, undefined)).toEqual(22);
+        });
+
+        // Valid values are 55, 57, 59, 61, 63, 65
+        it("should snap to a snap point based upon the minValue", function(){
+            expect(snapInRange(56, 2, 55, 65)).toEqual(57);
+        });
+
+        it("should enforce the minValue", function(){
+            expect(snapInRange(20, 2, 55, 65)).toEqual(55);
+        });
+
+        // Valid values are still 55, 57, 59, 61, 63, 65
+        it("should snap to a snap point based upon the minValue even if maxValue is not on a snap point", function(){
+            expect(snapInRange(100, 2, 55, 66)).toEqual(67);
+        });
+
+        it("should round to the nearest snap point", function() {
+            expect(snapInRange(4, 5, 0, 100)).toEqual(5);
+
+            expect(snapInRange(10, 10, 1, 101)).toBe(11);
+            expect(snapInRange(11, 10, 1, 101)).toBe(11);
+            expect(snapInRange(12, 10, 1, 101)).toBe(11);
+            expect(snapInRange(20, 10, 1, 101)).toBe(21);
+            expect(snapInRange(21, 10, 1, 101)).toBe(21);
+            expect(snapInRange(22, 10, 1, 101)).toBe(21);
+        });
+        
+        it("should handle negative ranges", function() {
+            expect(snapInRange(-10, 10, -101, -1)).toBe(-11);
+            expect(snapInRange(-11, 10, -101, -1)).toBe(-11);
+            expect(snapInRange(-12, 10, -101, -1)).toBe(-11);
+            expect(snapInRange(-20, 10, -101, -1)).toBe(-21);
+            expect(snapInRange(-21, 10, -101, -1)).toBe(-21);
+            expect(snapInRange(-22, 10, -101, -1)).toBe(-21);
+        });
+    });
+    
+    describe("from", function() {
+        var from = Ext.Number.from;
+       
+        it("should handle numbers", function() {
+            expect(from(2, 1)).toBe(2);
+            expect(from(-2, 1)).toBe(-2);
+            expect(from(999999, 1)).toBe(999999);
+            expect(from(-999999, 1)).toBe(-999999);
+            expect(from(999999.999, 1)).toBe(999999.999);
+            expect(from(-999999.999, 1)).toBe(-999999.999);
+        });
+           
+        it("should handle strings that represent numbers", function() {
+            expect(from("2", 1)).toBe(2);
+            expect(from("-2", 1)).toBe(-2);
+            expect(from("999999", 1)).toBe(999999);
+            expect(from("-999999", 1)).toBe(-999999);
+            expect(from("999999.999", 1)).toBe(999999.999);
+            expect(from("-999999.999", 1)).toBe(-999999.999);
+        });
+           
+        it("should handle infinity", function() {
+            expect(from(1/0, 1)).toBe(window.Number.POSITIVE_INFINITY);
+            expect(from(-1/0, 1)).toBe(window.Number.NEGATIVE_INFINITY);
+        });
+           
+        it("should return default value if value is not a number or numeric string", function() {
+            expect(from("", 100)).toBe(100); 
+            expect(from(true, 100)).toBe(100); 
+            expect(from(false, 100)).toBe(100); 
+            expect(from("I would like to be a number", 100)).toBe(100); 
+            expect(from("12345ImAlmostANumber", 100)).toBe(100); 
+        });
+    });
+    
+    describe("randomInt", function() {
+        var randomInt = Ext.Number.randomInt;
+        it("should return a random integer within the specified range", function() {
+            expect(randomInt(0, 100)).not.toBeLessThan(0);
+            expect(randomInt(0, 100)).not.toBeGreaterThan(100);
+            expect(randomInt(-100, 0)).not.toBeLessThan(-100);
+            expect(randomInt(-100, 0)).not.toBeGreaterThan(0);
+            expect(randomInt(1, 1)).toBe(1);
+            expect(randomInt(1, 1)).toBe(1);
+        });
+    });
+
+});

data/app/assets/javascripts/extjs-rails/src/core/test/unit/spec/lang/Object.js

@@ -0,0 +1,591 @@
+describe("Ext.Object", function(){
+
+    describe("getKeys", function(){
+        var getKeys = Ext.Object.getKeys;
+        it("should return an empty array for a null value", function(){
+            expect(getKeys(null)).toEqual([]);
+        });
+
+        it("should return an empty array for an empty object", function(){
+            expect(getKeys({})).toEqual([]);
+        });
+
+        it("should return all the keys in the object", function(){
+            expect(getKeys({
+                foo: 1,
+                bar: 2,
+                baz: 3
+            })).toEqual(['foo', 'bar', 'baz']);
+        });
+    });
+
+    describe("getValues", function(){
+        var getValues = Ext.Object.getValues;
+        it("should return an empty array for a null value", function(){
+            expect(getValues(null)).toEqual([]);
+        });
+
+        it("should return an empty array for an empty object", function(){
+            expect(getValues({})).toEqual([]);
+        });
+
+        it("should return all the values in the object", function(){
+            expect(getValues({
+                foo: 1,
+                bar: 2,
+                baz: 3
+            })).toEqual([1, 2, 3]);
+        });
+    });
+
+    describe("getKey", function(){
+        var getKey = Ext.Object.getKey;
+
+        it("should return null for a null object", function(){
+            expect(getKey(null, 'foo')).toBeNull();
+        });
+
+        it("should return null for an empty object", function(){
+            expect(getKey({}, 'foo')).toBeNull();
+        });
+
+        it("should return null if the value doesn't exist", function(){
+            expect(getKey({
+                foo: 1,
+                bar: 2
+            }, 3)).toBeNull();
+        });
+
+        it("should only do strict matching", function(){
+            expect(getKey({
+                foo: 1
+            }, '1')).toBeNull();
+        });
+
+        it("should return the correct key if it matches", function(){
+            expect(getKey({
+                foo: 1
+            }, 1)).toEqual('foo');
+        });
+
+        it("should only return the first matched value", function(){
+            expect(getKey({
+                bar: 1,
+                foo: 1
+            }, 1)).toEqual('bar');
+        });
+    });
+
+    describe("each", function(){
+        var each = Ext.Object.each;
+
+        describe("scope/params", function(){
+            it("should execute using the passed scope", function(){
+                var scope = {},
+                    actual;
+
+                each({
+                    foo: 1,
+                    bar: 'value',
+                    baz: false
+                }, function(){
+                    actual = this;
+                }, scope);
+                expect(actual).toBe(scope);
+            });
+
+            it("should default the scope to the object", function(){
+                var o = {
+                    foo: 1,
+                    bar: 'value',
+                    baz: false
+                }, actual;
+
+                each(o, function(){
+                    actual = this;
+                });
+                expect(actual).toBe(o);
+            });
+
+            it("should execute passing the key value and object", function(){
+                var keys = [],
+                    values = [],
+                    data = {
+                        foo: 1,
+                        bar: 'value',
+                        baz: false
+                    },
+                    obj;
+
+                each(data, function(key, value, o){
+                    keys.push(key);
+                    values.push(value);
+                    obj = o;
+                });
+
+                expect(keys).toEqual(['foo', 'bar', 'baz']);
+                expect(values).toEqual([1, 'value', false]);
+                expect(obj).toBe(data);
+            });
+        });
+
+        describe("stopping", function(){
+            it("should not stop by default", function(){
+                var count = 0;
+                each({
+                    a: 1,
+                    b: 2,
+                    c: 3,
+                    d: 4
+                }, function(){
+                    ++count;
+                });
+                expect(count).toEqual(4);
+            });
+
+            it("should only stop if the function returns false", function(){
+                var count = 0;
+                each({
+                    a: 1,
+                    b: 2,
+                    c: 3,
+                    d: 4
+                }, function(){
+                    ++count;
+                    return null;
+                });
+                expect(count).toEqual(4);
+            });
+
+            it("should stop immediately when false is returned", function(){
+                var count = 0;
+                each({
+                    a: 1,
+                    b: 2,
+                    c: 3,
+                    d: 4
+                }, function(key){
+                    ++count;
+                    return key != 'b';
+                });
+                expect(count).toEqual(2);
+            });
+        });
+    });
+
+    describe("toQueryString", function(){
+        var toQueryString = Ext.Object.toQueryString;
+
+        describe("defaults", function(){
+            it("should return an empty string for a null object", function(){
+                expect(toQueryString(null)).toEqual('');
+            });
+
+            it("should return an empty string for an empty object", function(){
+                expect(toQueryString({})).toEqual('');
+            });
+        });
+
+        describe("simple values", function(){
+            it("should separate a property/value by an =", function(){
+                expect(toQueryString({
+                    foo: 1
+                })).toEqual('foo=1');
+            });
+
+            it("should separate pairs by an &", function(){
+                expect(toQueryString({
+                    foo: 1,
+                    bar: 2
+                })).toEqual('foo=1&bar=2');
+            });
+
+            it("should handle properties with empty values", function(){
+                expect(toQueryString({
+                    foo: null
+                })).toEqual('foo=');
+            });
+
+            it("should encode dates", function(){
+                var d = new Date(2011, 0, 1);
+                expect(toQueryString({
+                    foo: d
+                })).toEqual('foo=2011-01-01T00%3A00%3A00');
+            });
+
+            it("should url encode the key", function(){
+                expect(toQueryString({
+                    'a prop': 1
+                })).toEqual('a%20prop=1');
+            });
+
+            it("should url encode the value", function(){
+                expect(toQueryString({
+                    prop: '$300 & 5 cents'
+                })).toEqual('prop=%24300%20%26%205%20cents');
+            });
+
+            it("should encode both key and value at the same time", function(){
+               expect(toQueryString({
+                   'a prop': '$300'
+               })).toEqual('a%20prop=%24300');
+            });
+        });
+
+        describe("arrays", function(){
+            it("should support an array value", function(){
+                expect(toQueryString({
+                    foo: [1, 2, 3]
+                })).toEqual('foo=1&foo=2&foo=3');
+            });
+
+            it("should be able to support multiple arrays", function(){
+                expect(toQueryString({
+                    foo: [1, 2],
+                    bar: [3, 4]
+                })).toEqual('foo=1&foo=2&bar=3&bar=4');
+            });
+
+            it("should be able to mix arrays and normal values", function(){
+                expect(toQueryString({
+                    foo: 'val1',
+                    bar: ['val2', 'val3'],
+                    baz: 'val4'
+                })).toEqual('foo=val1&bar=val2&bar=val3&baz=val4');
+            });
+        });
+
+        describe("recursive", function() {
+            it("should support both nested arrays and objects", function() {
+                expect(decodeURIComponent(Ext.Object.toQueryString({
+                    username: 'Jacky',
+                    dateOfBirth: {
+                        day: 1,
+                        month: 2,
+                        year: 1911
+                    },
+                    hobbies: ['coding', 'eating', 'sleeping', [1,2]]
+                }, true))).toEqual('username=Jacky&dateOfBirth[day]=1&dateOfBirth[month]=2&dateOfBirth[year]=1911&hobbies[0]=coding&hobbies[1]=eating&hobbies[2]=sleeping&hobbies[3][0]=1&hobbies[3][1]=2')
+            })
+        });
+
+    });
+
+    describe("merge", function(){
+        var merge = Ext.Object.merge;
+
+        describe("complex values", function(){
+            it("should copy a simple object but not have the same reference", function(){
+                var o = {
+                    foo: 'prop',
+                    tada: {
+                        blah: 'bleh'
+                    }
+                },
+                result = merge({}, o);
+
+                expect(result).toEqual({
+                    foo: 'prop',
+                    tada: {
+                        blah: 'bleh'
+                    }
+                });
+                expect(result).not.toBe(o);
+            });
+
+            it("should NOT merge an instance (the constructor of which is not Object)", function(){
+                var instance = new Ext.Base(),
+                    o = {
+                        foo: instance
+                    },
+                    result = merge({}, o);
+
+                expect(result.foo).toBe(instance);
+            });
+        });
+
+        describe("overwriting properties", function(){
+            it("should merge objects if an object exists on the source and the passed value is an object literal", function(){
+                expect(merge({
+                    prop: {
+                        foo: 1
+                    }
+                }, {
+                    prop: {
+                        bar: 2
+                    }
+                })).toEqual({
+                    prop: {
+                        foo: 1,
+                        bar: 2
+                    }
+                });
+            });
+
+            it("should replace the value of the target object if it is not an object", function(){
+                var o = new Ext.Base(),
+                    result = merge({
+                        prop: 1
+                    }, {
+                        prop: o
+                    });
+
+                expect(result.prop).toEqual(o);
+                expect(result.prop).toBe(o);
+            });
+
+            it("should overwrite simple values", function(){
+                expect(merge({
+                    prop: 1
+                }, {
+                    prop: 2
+                })).toEqual({
+                    prop: 2
+                });
+            });
+        });
+
+        describe("merging objects", function(){
+            it("should merge objects", function(){
+                expect(merge({}, {
+                    foo: 1
+                })).toEqual({
+                    foo: 1
+                });
+            });
+
+            it("should merge right to left", function(){
+                expect(merge({}, {
+                    foo: 1
+                }, {
+                    foo: 2
+                }, {
+                    foo: 3
+                })).toEqual({
+                    foo: 3
+                })
+            });
+        });
+
+        it("should modify and return the source", function(){
+            var o = {},
+                result = merge(o, {
+                    foo: 'bar'
+                });
+
+            expect(result.foo).toEqual('bar');
+            expect(result).toBe(o);
+
+        });
+    });
+
+    describe("toQueryObjects", function() {
+        var object = {
+            username: 'Jacky',
+            dateOfBirth: {
+                day: 1,
+                month: 2,
+                year: 1911
+            },
+            hobbies: ['coding', 'eating', 'sleeping', [1,2,3]]
+        };
+
+        it("simple key value", function() {
+            expect(Ext.Object.toQueryObjects('username', 'Jacky')).toEqual([
+                {
+                    name: 'username',
+                    value: 'Jacky'
+                }
+            ]);
+        });
+
+        it("non-recursive array", function() {
+            expect(Ext.Object.toQueryObjects('hobbies', ['eating', 'sleeping', 'coding'])).toEqual([
+                {
+                    name: 'hobbies',
+                    value: 'eating'
+                },
+                {
+                    name: 'hobbies',
+                    value: 'sleeping'
+                },
+                {
+                    name: 'hobbies',
+                    value: 'coding'
+                }
+            ]);
+        });
+
+        it("recursive object", function() {
+            expect(Ext.Object.toQueryObjects('dateOfBirth', {
+                day: 1,
+                month: 2,
+                year: 1911,
+                somethingElse: {
+                    nested: {
+                        very: 'very',
+                        deep: {
+                            inHere: true
+                        }
+                    }
+                }
+            }, true)).toEqual([
+                {
+                    name: 'dateOfBirth[day]',
+                    value: 1
+                },
+                {
+                    name: 'dateOfBirth[month]',
+                    value: 2
+                },
+                {
+                    name: 'dateOfBirth[year]',
+                    value: 1911
+                },
+                {
+                    name: 'dateOfBirth[somethingElse][nested][very]',
+                    value: 'very'
+                },
+                {
+                    name: 'dateOfBirth[somethingElse][nested][deep][inHere]',
+                    value: true
+                }
+            ]);
+        });
+
+        it("recursive array", function() {
+            expect(Ext.Object.toQueryObjects('hobbies', [
+                'eating', 'sleeping', 'coding', ['even', ['more']]
+            ], true)).toEqual([
+                {
+                    name: 'hobbies[0]',
+                    value: 'eating'
+                },
+                {
+                    name: 'hobbies[1]',
+                    value: 'sleeping'
+                },
+                {
+                    name: 'hobbies[2]',
+                    value: 'coding'
+                },
+                {
+                    name: 'hobbies[3][0]',
+                    value: 'even'
+                },
+                {
+                    name: 'hobbies[3][1][0]',
+                    value: 'more'
+                }
+            ]);
+        });
+    });
+
+    describe("fromQueryString", function() {
+        var fromQueryString = Ext.Object.fromQueryString;
+
+        describe("standard mode", function() {
+            it("empty string", function(){
+                expect(fromQueryString('')).toEqual({});
+            });
+
+            it("simple single key value pair", function(){
+                expect(fromQueryString('name=Jacky')).toEqual({name: 'Jacky'});
+            });
+
+            it("simple single key value pair with empty value", function(){
+                expect(fromQueryString('name=')).toEqual({name: ''});
+            });
+
+            it("multiple key value pairs", function(){
+                expect(fromQueryString('name=Jacky&loves=food')).toEqual({name: 'Jacky', loves: 'food'});
+            });
+
+            it("multiple key value pairs with URI encoded component", function(){
+                expect(fromQueryString('a%20property=%24300%20%26%205%20cents')).toEqual({'a property': '$300 & 5 cents'});
+            });
+
+            it("simple array", function(){
+                expect(fromQueryString('foo=1&foo=2&foo=3')).toEqual({foo: ['1', '2', '3']});
+            });
+        });
+
+        describe("recursive mode", function() {
+            it("empty string", function(){
+                expect(fromQueryString('', true)).toEqual({});
+            });
+
+            it("simple single key value pair", function(){
+                expect(fromQueryString('name=Jacky', true)).toEqual({name: 'Jacky'});
+            });
+
+            it("simple single key value pair with empty value", function(){
+                expect(fromQueryString('name=', true)).toEqual({name: ''});
+            });
+
+            it("multiple key value pairs", function(){
+                expect(fromQueryString('name=Jacky&loves=food', true)).toEqual({name: 'Jacky', loves: 'food'});
+            });
+
+            it("multiple key value pairs with URI encoded component", function(){
+                expect(fromQueryString('a%20property=%24300%20%26%205%20cents', true)).toEqual({'a property': '$300 & 5 cents'});
+            });
+
+            it("simple array (last value with the same name will overwrite previous value)", function(){
+                expect(fromQueryString('foo=1&foo=2&foo=3', true)).toEqual({foo: '3'});
+            });
+
+            it("simple array with empty brackets", function(){
+                expect(fromQueryString('foo[]=1&foo[]=2&foo[]=3', true)).toEqual({foo: ['1', '2', '3']});
+            });
+
+            it("simple array with non-empty brackets", function(){
+                expect(fromQueryString('foo[0]=1&foo[1]=2&foo[2]=3', true)).toEqual({foo: ['1', '2', '3']});
+            });
+
+            it("simple array with non-empty brackets and non sequential keys", function(){
+                expect(fromQueryString('foo[3]=1&foo[1]=2&foo[2]=3&foo[0]=0', true)).toEqual({foo: ['0', '2', '3', '1']});
+            });
+
+            it("simple array with non-empty brackets and non sequential keys and holes", function(){
+                expect(fromQueryString('foo[3]=1&foo[1]=2&foo[2]=3', true)).toEqual({foo: [undefined, '2', '3', '1']});
+            });
+
+            it("nested array", function(){
+                expect(fromQueryString('some[0][0]=stuff&some[0][1]=morestuff&some[0][]=otherstuff&some[1]=thingelse', true)).toEqual({
+                    some: [
+                        ['stuff', 'morestuff', 'otherstuff'],
+                        'thingelse'
+                    ]
+                });
+            });
+
+            it("nested object", function(){
+                expect(fromQueryString('dateOfBirth[day]=1&dateOfBirth[month]=2&dateOfBirth[year]=1911&dateOfBirth[extra][hour]=4&dateOfBirth[extra][minute]=30', true)).toEqual({
+                    dateOfBirth: {
+                        day: '1',
+                        month: '2',
+                        year: '1911',
+                        extra: {
+                            hour: '4',
+                            minute: '30'
+                        }
+                    }
+                });
+            });
+
+            it("nested mixed types", function(){
+                expect(fromQueryString('username=Jacky&dateOfBirth[day]=1&dateOfBirth[month]=2&dateOfBirth[year]=1911&hobbies[0]=coding&hobbies[1]=eating&hobbies[2]=sleeping&hobbies[3][0]=nested&hobbies[3][1]=stuff', true)).toEqual({
+                    username: 'Jacky',
+                    dateOfBirth: {
+                        day: '1',
+                        month: '2',
+                        year: '1911'
+                    },
+                    hobbies: ['coding', 'eating', 'sleeping', ['nested', 'stuff']]
+                });
+            });
+        });
+    });
+
+});