jax 1.1.1 → 2.0.0

data/spec/javascripts/jax/core/data_region_spec.js

@@ -0,0 +1,118 @@
+describe("Jax.DataRegion", function() {
+  var region;//, BYTES = 16*Float32Array.BYTES_PER_ELEMENT+4*Uint16Array.BYTES_PER_ELEMENT;
+  
+  describe("for default bytes", function() {
+    beforeEach(function() { region = new Jax.DataRegion(); });
+    
+    it("remap with groups", function() {
+      var vdata = region.map(Float32Array, 0);
+      var vgroup = vdata.group(3);
+      
+      region.remap(vdata, 6);
+      expect(vgroup.length).toEqual(2);
+    });
+    
+    it("map several segments", function() {
+      var vertices = [0,0,0], colors = [1,1,1,1], textureCoords = [], normals = [], indices = [1];
+      
+      var vertexData        = region.map(Float32Array, vertices);
+      var colorData         = region.map(Float32Array, colors);
+      var textureCoordsData = region.map(Float32Array, textureCoords);
+      var normalData        = region.map(Float32Array, normals);
+      var indices           = region.map(Uint16Array,  indices);
+      
+      expect(vertexData.length).toEqual(3);
+      expect(colorData.length).toEqual(4);
+      expect(textureCoordsData.length).toEqual(0);
+      expect(normalData.length).toEqual(0);
+      expect(indices.length).toEqual(1);
+    });
+    
+    describe("map with default values", function() {
+      it("standard", function() {
+        var vertices = region.map(Float32Array, 4, [1,2,3,4]);
+        expect(vertices.array).toEqualVector([1,2,3,4]);
+      });
+      
+      it("without a length", function() {
+        var colors = region.map(Float32Array, [0.0, 0.1, 0.2, 0.3]);
+        expect(colors.array).toEqualVector([0.0, 0.1, 0.2, 0.3]);
+      });
+      
+      it("with fewer elements in defaults than length", function() {
+        expect(region.map(Float32Array, 4, [1,2,3]).array).toEqualVector([1,2,3,0]);
+      });
+    });
+    
+    describe("remap with default values", function() {
+      it("standard", function() {
+        var vertices = region.map(Float32Array, 4);
+        region.remap(vertices, 3, [1,2,3]);
+        expect(vertices.array).toEqualVector([1,2,3]);
+      });
+      
+      it("without a length", function() {
+        var colors = region.map(Float32Array, [0.0, 0.1, 0.2, 0.3]);
+        region.remap(colors, [0.1, 0.2]);
+        expect(colors.array).toEqualVector([0.1, 0.2]);
+      });
+      
+      it("with fewer elements in defaults than length", function() {
+        var n = region.map(Float32Array, 4, [1,2,3]);
+        region.remap(n, 3, [4,3]);
+        expect(n.array).toEqualVector([4,3,3]);
+      });
+    });
+    
+    describe("12-element Float32Array", function() {
+      var vertices;
+      beforeEach(function() {
+        vertices = region.map(Float32Array, 12);
+        for (var i = 0; i < 12; i++) vertices[i] = i;
+      });
+      
+      it("should have length 12", function() { expect(vertices.length).toEqual(12); });
+      
+      describe("additional 4-element Uint16Array", function() {
+        var indices;
+        beforeEach(function() {
+          indices = region.map(Uint16Array, 4);
+          for (var i = 0; i < 4; i++)
+            indices[i] = i;
+        });
+        
+        it("should have length 4", function() { expect(indices.length).toEqual(4); });
+        
+        it("should share underlying buffer with vertices", function() {
+          expect(indices.buffer).toBe(vertices.buffer);
+        });
+        
+        it("should not share data with vertices", function() {
+          indices[0] = 100;
+          expect(vertices[0]).toEqual(0);
+        });
+        
+        describe("remapping Float32Array into 16 elements", function() {
+          beforeEach(function() { region.remap(vertices, 16); });
+          
+          it("should have length 16", function() {
+            expect(vertices.length).toEqual(16);
+          });
+          
+          it("should not overlap indices", function() {
+            indices[0] = 100;
+            for (var i = 0; i < 16; i++) vertices[i] = i;
+            expect(indices[0]).toEqual(100);
+          });
+          
+          it("should initialize new values to 0", function() {
+            for (var i = 0; i < 4; i++) {
+              expect(vertices[i+12]).toEqual(0);
+            }
+          });
+        });
+      });
+    });
+  });
+
+});

data/spec/javascripts/jax/core/data_segment_spec.js

@@ -0,0 +1,96 @@
+describe("Jax.DataSegment", function() {
+  var seg;
+  beforeEach(function() {
+    seg = new Jax.DataSegment(Float32Array, 9);
+    for (var i = 0; i < 9; i++) seg.array[i] = i;
+  });
+  
+  describe("grouping", function() {
+    var group;
+    beforeEach(function() { group = seg.group(3); });
+    
+    it("should complain when array size is not divisible by group size", function() {
+      expect(function() { seg.group(2); }).toThrow("Data segment size 9 is not divisible by group size 2");
+    });
+    
+    it("should group data", function() {
+      expect(group.length).toEqual(3);
+      for (var i = 0; i < 3; i++)
+        expect(group[i].array).toEqualVector([seg.array[i*3], seg.array[i*3+1], seg.array[i*3+2]]);
+    });
+    
+    it("should update group when array changes", function() {
+      var firstGroup = group[0];
+      
+      seg.setArray(new Float32Array([1, 2, 3, 4, 5, 6]));
+      
+      expect(group.length).toEqual(2);
+      for (var i = 0; i < 2; i++)
+        expect(group[i].array).toEqualVector([i*3+1, i*3+2, i*3+3]);
+        
+      expect(firstGroup).toBe(group[0]);
+    });
+  });
+  
+  xit("reflection", function() {
+    // reflection is currently too slow to be used realistically
+    // so it and its tests are disabled for now.
+    seg.array[0] = 1;
+    seg.array[1] = 2;
+    seg.array[2] = 3;
+    
+    expect(seg[0]).toEqual(1);
+    expect(seg[1]).toEqual(2);
+    expect(seg[2]).toEqual(3);
+    
+    seg[0] = 4;
+    seg[1] = 5;
+    seg[2] = 6;
+    
+    expect(seg.array[0]).toEqual(4);
+    expect(seg.array[1]).toEqual(5);
+    expect(seg.array[2]).toEqual(6);
+  });
+  
+  describe('getters', function() {
+    xit("should be zero", function() {
+      // see reflection
+      expect(seg[0]).toEqual(0);
+    });
+  });
+  
+  describe("setters", function() {
+    xit("by index", function() {
+      // see reflection
+      expect(seg[0] = 1).toEqual(1);
+      expect(seg[0]).toEqual(1);
+    });
+    
+    it("#set", function() {
+      var f = new Float32Array(1);
+      f[0] = 1;
+      
+      seg.set(f);
+      expect(seg.array).toEqualVector([1,1,2,3,4,5,6,7,8]);
+      
+      seg.set(f, 2);
+      expect(seg.array).toEqualVector([1,1,1,3,4,5,6,7,8]);
+    });
+  });
+  
+  it("#setArray", function() {
+    // sanity check
+    expect(Jax.Util.properties(seg.array)).toContain('2');
+    
+    seg.setArray(new Float32Array(2));
+
+    expect(seg.length).toEqual(2);
+    expect(Jax.Util.properties(seg.array)).not.toContain('2');
+  });
+  
+  it("#subarray", function() {
+    seg.set([1,2,3]);
+    expect(seg.subarray(1,3).array).toEqualVector([2, 3]);
+    expect(seg.subarray(1,3)).toBeKindOf(Jax.DataSegment);
+  });
+});

data/spec/javascripts/jax/core/delegation_spec.js

@@ -0,0 +1,48 @@
+describe("Delegation", function() {
+  /* see src/jax/prototype/extensions.js */
+  var klass;
+  
+  beforeEach(function() { klass = Jax.Class.create({initialize:function(){this.matrix_stack=new Jax.MatrixStack();}}); });
+  
+  it("should delegate via string", function() {
+    klass.delegate("getProjectionMatrix", "loadModelMatrix").into("matrix_stack");
+    
+    var src = new klass();
+    spyOn(src.matrix_stack, 'getProjectionMatrix');
+    spyOn(src.matrix_stack, 'loadModelMatrix');
+    
+    src.getProjectionMatrix();
+    src.loadModelMatrix(mat4.create());
+    
+    expect(src.matrix_stack.getProjectionMatrix).toHaveBeenCalled();
+    expect(src.matrix_stack.loadModelMatrix).toHaveBeenCalled();
+  });
+  
+  it("should delegate via regexp with explicit klass", function() {
+    klass.delegate(/^(get|load|mult)(.*)Matrix$/).into("matrix_stack", Jax.MatrixStack);
+    
+    var src = new klass();
+    spyOn(src.matrix_stack, 'getProjectionMatrix');
+    spyOn(src.matrix_stack, 'loadModelMatrix');
+    
+    src.getProjectionMatrix();
+    src.loadModelMatrix(mat4.create());
+    
+    expect(src.matrix_stack.getProjectionMatrix).toHaveBeenCalled();
+    expect(src.matrix_stack.loadModelMatrix).toHaveBeenCalled();
+  });
+  
+  it("should delegate via regexp without explicit klass", function() {
+    klass.delegate(/^(get|load|mult)(.*)Matrix$/).into("matrix_stack");
+    
+    var src = new klass();
+    spyOn(src.matrix_stack, 'getProjectionMatrix');
+    spyOn(src.matrix_stack, 'loadModelMatrix');
+    
+    src.getProjectionMatrix();
+    src.loadModelMatrix(mat4.create());
+    
+    expect(src.matrix_stack.getProjectionMatrix).toHaveBeenCalled();
+    expect(src.matrix_stack.loadModelMatrix).toHaveBeenCalled();
+  });
+});

data/spec/javascripts/jax/core/events_spec.js

@@ -0,0 +1,17 @@
+describe("Jax.Events", function() {
+  describe("Methods", function() {
+    var instance;
+    beforeEach(function() {
+      var klass = Jax.Class.create({});
+      klass.addMethods(Jax.Events.Methods);
+      instance = new klass();
+    });
+    
+    it("should pass events to listeners", function() {
+      var result = false;
+      instance.addEventListener('evt', function(evt) { result = evt; });
+      instance.fireEvent('evt', 1);
+      expect(result).toBeTruthy();
+    });
+  });
+});

data/spec/javascripts/jax/core/glMatrix_extensions_spec.js

@@ -0,0 +1,8 @@
+describe("glMatrix extensions", function() {
+  describe("#toAngleAxis", function() {
+    var quat;
+    
+    describe("with no rotation", function() {
+    });
+  });
+});

data/spec/javascripts/jax/core/helper_spec.js

@@ -0,0 +1,61 @@
+describe("Jax.Helper", function() {
+  var helper;
+  
+  beforeEach(function() {
+    helper = Jax.Helper.create({
+      test_method: function() { return 1; }
+    });
+  });
+
+  describe("with an array", function() {
+    it("should define the helper in requesting controllers", function() {
+      var controller = Jax.Controller.create({
+        helpers: [helper]
+      });
+      expect(controller.prototype.test_method).toEqual(helper.test_method);
+    });
+
+    it("should not define the helper in non-requesting controllers", function() {
+      var controller = Jax.Controller.create({});
+      expect(controller.prototype.test_method).toBeUndefined();
+    });
+
+    it("should define the helper in requesting models", function() {
+      var model = Jax.Class.create(Jax.Model, {
+        helpers: [helper]
+      });
+      expect(model.prototype.test_method).toEqual(helper.test_method);
+    });
+
+    it("should not define the helper in non-requesting models", function() {
+      var model = Jax.Class.create(Jax.Model, {});
+      expect(model.prototype.test_method).toBeUndefined();
+    });
+  });
+  
+  describe("with a function", function() {
+    it("should define the helper in requesting controllers", function() {
+      var controller = Jax.Controller.create({
+        helpers: function() { return [helper]; }
+      });
+      expect(controller.prototype.test_method).toEqual(helper.test_method);
+    });
+
+    it("should not define the helper in non-requesting controllers", function() {
+      var controller = Jax.Controller.create({});
+      expect(controller.prototype.test_method).toBeUndefined();
+    });
+
+    it("should define the helper in requesting models", function() {
+      var model = Jax.Class.create(Jax.Model, {
+        helpers: function() { return [helper]; }
+      });
+      expect(model.prototype.test_method).toEqual(helper.test_method);
+    });
+
+    it("should not define the helper in non-requesting models", function() {
+      var model = Jax.Class.create(Jax.Model, {});
+      expect(model.prototype.test_method).toBeUndefined();
+    });
+  });
+});

data/spec/javascripts/jax/core/matrix_stack_spec.js

@@ -0,0 +1,28 @@
+describe("Jax.MatrixStack", function() {
+  var stack;
+  
+  beforeEach(function() { stack = new Jax.MatrixStack(); });
+  
+  it('should return a model matrix', function() { expect(stack.getModelMatrix()).not.toBeUndefined(); });
+  it('should return a view matrix', function() { expect(stack.getViewMatrix()).not.toBeUndefined(); });
+  it('should return a proj matrix', function() { expect(stack.getProjectionMatrix()).not.toBeUndefined(); });
+      
+  describe("with a pushed matrix", function() {
+    beforeEach(function() { stack.push(); });
+    
+    it('should return a model matrix', function() { expect(stack.getModelMatrix()).not.toBeUndefined(); });
+    it('should return a view matrix', function() { expect(stack.getViewMatrix()).not.toBeUndefined(); });
+    it('should return a proj matrix', function() { expect(stack.getProjectionMatrix()).not.toBeUndefined(); });
+      
+    describe("translate", function() {
+      beforeEach(function() { stack.loadViewMatrix(mat4.translate(mat4.IDENTITY, [1,1,1], mat4.create())); });
+      
+      it("should not be an identity matrix", function() { expect(stack.getViewMatrix()).not.toEqualMatrix(mat4.IDENTITY); });
+      
+      it("should produce coords relative to eye", function() {
+        var vec = mat4.multiplyVec3(stack.getInverseViewMatrix(), [0,0,0]);
+        expect(vec).toEqualVector([-1,-1,-1]);
+      });
+    });
+  });
+});

data/spec/javascripts/jax/core/utils_spec.js

@@ -0,0 +1,275 @@
+describe("Jax.Util", function() {
+  describe("vectorize", function() {
+    var data;
+    
+    describe("2D", function() {
+      beforeEach(function() { data = [1, 2]; });
+      
+      it("should have length 2", function() { expect(Jax.Util.vectorize({x:0,y:1})).toEqualVector([0,1]); });
+      it("should work", function() { expect(Jax.Util.vectorize(data)).toEqualVector([1,2]); });
+    });
+    
+    describe("with array", function() {
+      beforeEach(function() { data = [1, 2, 3]; });
+      
+      it("should return the original vector", function() { expect(Jax.Util.vectorize(data)).toEqualVector([1,2,3]); });
+    });
+    
+    describe("with object with names", function() {
+      beforeEach(function() { data = {x:1,y:2,z:3}; });
+      it("should produce a vector", function() { expect(Jax.Util.vectorize(data)).toEqualVector([1,2,3]); });
+    });
+    
+    describe("with string", function() {
+      describe("comma delimited", function() {
+        beforeEach(function() { data = "1,2,3"; });
+        it("should produce a vector", function() { expect(Jax.Util.vectorize(data)).toEqualVector([1,2,3]); });
+      });
+      describe("space delimited", function() {
+        beforeEach(function() { data = "1 2 3"; });
+        it("should produce a vector", function() { expect(Jax.Util.vectorize(data)).toEqualVector([1,2,3]); });
+      });
+      describe("comma-and-space delimited", function() {
+        beforeEach(function() { data = "1, 2, 3"; });
+        it("should produce a vector", function() { expect(Jax.Util.vectorize(data)).toEqualVector([1,2,3]); });
+      });
+      describe("tab delimited", function() {
+        beforeEach(function() { data = "1\t2\t3"; });
+        it("should produce a vector", function() { expect(Jax.Util.vectorize(data)).toEqualVector([1,2,3]); });
+      });
+      describe("comma-space-tab delimited", function() {
+        beforeEach(function() { data = "1, \t2, \t3"; });
+        it("should produce a vector", function() { expect(Jax.Util.vectorize(data)).toEqualVector([1,2,3]); });
+      });
+    });
+    
+    describe("colorize", function() {
+      var data;
+    
+      describe("3D", function() {
+        beforeEach(function() { data = [1, 2, 3]; });
+
+        it("should work", function() { expect(Jax.Util.colorize(data)).toEqualVector([1,2,3,1]); });
+      });
+
+      describe("with object with short names", function() {
+        beforeEach(function() { data = {r:1,g:2,b:3,a:4}; });
+        it("should produce a color", function() { expect(Jax.Util.colorize(data)).toEqualVector([1,2,3,4]); });
+      });
+    
+      describe("with object with long names", function() {
+        beforeEach(function() { data = {red:1,green:2,blue:3,alpha:4}; });
+        it("should produce a color", function() { expect(Jax.Util.colorize(data)).toEqualVector([1,2,3,4]); });
+      });
+    
+      describe("with string", function() {
+        describe("comma delimited", function() {
+          beforeEach(function() { data = "1,2,3,4"; });
+          it("should produce a color", function() { expect(Jax.Util.colorize(data)).toEqualVector([1,2,3,4]); });
+        });
+        describe("space delimited", function() {
+          beforeEach(function() { data = "1 2 3 4"; });
+          it("should produce a color", function() { expect(Jax.Util.colorize(data)).toEqualVector([1,2,3,4]); });
+        });
+        describe("comma-and-space delimited", function() {
+          beforeEach(function() { data = "1, 2, 3, 4"; });
+          it("should produce a color", function() { expect(Jax.Util.colorize(data)).toEqualVector([1,2,3,4]); });
+        });
+        describe("tab delimited", function() {
+          beforeEach(function() { data = "1\t2\t3\t4"; });
+          it("should produce a color", function() { expect(Jax.Util.colorize(data)).toEqualVector([1,2,3,4]); });
+        });
+        describe("comma-space-tab delimited", function() {
+          beforeEach(function() { data = "1, \t2, \t3, \t4"; });
+          it("should produce a color", function() { expect(Jax.Util.colorize(data)).toEqualVector([1,2,3,4]); });
+        });
+      });
+
+      describe("with object with short names and no alpha", function() {
+        beforeEach(function() { data = {r:1,g:2,b:3}; });
+        it("should produce a color", function() { expect(Jax.Util.colorize(data)).toEqualVector([1,2,3,1]); });
+      });
+    
+      describe("with object with long names and no alpha", function() {
+        beforeEach(function() { data = {red:1,green:2,blue:3}; });
+        it("should produce a color", function() { expect(Jax.Util.colorize(data)).toEqualVector([1,2,3,1]); });
+      });
+    
+      describe("with string", function() {
+        describe("comma delimited and no alpha", function() {
+          beforeEach(function() { data = "1,2,3"; });
+          it("should produce a color", function() { expect(Jax.Util.colorize(data)).toEqualVector([1,2,3,1]); });
+        });
+        describe("space delimited and no alpha", function() {
+          beforeEach(function() { data = "1 2 3"; });
+          it("should produce a color", function() { expect(Jax.Util.colorize(data)).toEqualVector([1,2,3,1]); });
+        });
+        describe("comma-and-space delimited and no alpha", function() {
+          beforeEach(function() { data = "1, 2, 3"; });
+          it("should produce a color", function() { expect(Jax.Util.colorize(data)).toEqualVector([1,2,3,1]); });
+        });
+        describe("tab delimited and no alpha", function() {
+          beforeEach(function() { data = "1\t2\t3"; });
+          it("should produce a color", function() { expect(Jax.Util.colorize(data)).toEqualVector([1,2,3,1]); });
+        });
+        describe("comma-space-tab delimited and no alpha", function() {
+          beforeEach(function() { data = "1, \t2, \t3"; });
+          it("should produce a color", function() { expect(Jax.Util.colorize(data)).toEqualVector([1,2,3,1]); });
+        });
+      });
+    });
+    
+    describe("with object with indices", function() {
+      beforeEach(function() { data = {0:1,1:2,2:3}; });
+      it("should produce a vector", function() { expect(Jax.Util.vectorize(data)).toEqualVector([1,2,3]); });
+    });
+    
+    describe("with a vector", function() {
+      beforeEach(function() { data = [1,2,3]; });
+      it("should produce a vector", function() { expect(Jax.Util.vectorize(data)).toEqualVector([1,2,3]); });
+      xit("should not return itself", function() { expect(Jax.Util.vectorize(data)).not.toEqual(data); });
+    });
+  });
+  
+  describe("properties", function() {
+    var src;
+    beforeEach(function() { src = { prop1: 1, prop2: 2 }; });
+    it("should return property names", function() {
+      expect(Jax.Util.properties(src)).toEqual(['prop1', 'prop2']);
+    });
+  });
+  
+  describe("merge", function() {
+    var src, dst;
+    describe("with a source with null attributes and destination with existing attributes of same name", function() {
+      beforeEach(function() { src = {i:null}; dst = {i:5}; Jax.Util.merge(src,dst); });
+      
+      it("should copy null attributes", function() {
+        expect(dst.i).toBeNull();
+      });
+    });
+  });
+  
+  describe("sizeofFormat", function() {
+    it("should return size of ALPHA", function() { expect(Jax.Util.sizeofFormat(GL_ALPHA)).toEqual(1); });
+    it("should return size of LUMINANCE", function() { expect(Jax.Util.sizeofFormat(GL_LUMINANCE)).toEqual(1); });
+    it("should return size of RGB", function() { expect(Jax.Util.sizeofFormat(GL_RGB)).toEqual(3); });
+    it("should return size of RGBA", function() { expect(Jax.Util.sizeofFormat(GL_RGBA)).toEqual(4); });
+    it("should return size of LUMINANCE_ALPHA", function() { expect(Jax.Util.sizeofFormat(GL_LUMINANCE_ALPHA)).toEqual(2); });
+    it("should fail", function() { expect(function(){Jax.Util.sizeofFormat(-12345);}).toThrow(); });
+  });
+  
+  describe("enumName", function() {
+    it("should work", function() {
+      expect(Jax.Util.enumName(GL_TEXTURE_2D)).toEqual("GL_TEXTURE_2D");
+    });
+    
+    describe("failure", function() {
+      it("should contain the decimal form", function() {
+        expect(Jax.Util.enumName(36059)).toMatch(/36059/);
+      });
+
+      it("should contain the hex form", function() {
+        expect(Jax.Util.enumName(36059)).toMatch(/0x8cdb/);
+      });
+    });
+  });
+  
+  describe("normalizeOptions", function() {
+    var normalized;
+    describe("with a missing default array", function() {
+      var arr = [1,2,3];
+      beforeEach(function() { normalized = Jax.Util.normalizeOptions(null, {def:arr}); });
+      
+      it("should copy the default array", function() {
+        expect(normalized.def.length).toEqual(arr.length);
+        for (var i = 0; i < arr.length; i++)
+          expect(normalized.def[i]).toEqual(arr[i]);
+      });
+    });
+    
+    describe("with only 1 argument", function() {
+      it("should clone the argument", function() {
+        expect(Jax.Util.normalizeOptions({i:1}).i).toEqual(1);
+      });
+    });
+    
+    describe("with a  object left and array right", function() {
+      beforeEach(function() { normalized = Jax.Util.normalizeOptions({p:{"x":20,"y":40,"z":60}}, {p:[1,2,3]}); });
+      it("should merge both into a gen object", function() {
+        expect(Object.isArray(normalized.p)).toBeFalsy();
+
+        expect(normalized.p.x).toEqual(20);
+        expect(normalized.p.y).toEqual(40);
+        expect(normalized.p.z).toEqual(60);
+        expect(normalized.p[0]).toEqual(1);
+        expect(normalized.p[1]).toEqual(2);
+        expect(normalized.p[2]).toEqual(3);
+      });
+    });
+    
+    describe("with a function value that defaults to null", function() {
+      beforeEach(function() { normalized = Jax.Util.normalizeOptions({onload:function(){}}, {onload:null}); });
+      
+      it("should assign the function value", function() {
+        expect(typeof(normalized.onload)).toEqual("function");
+      });
+    });
+    
+    describe("with a missing value that defaults to null", function() {
+      beforeEach(function() { normalized = Jax.Util.normalizeOptions({}, {onload:null}); });
+      
+      it("should assign the default value", function() {
+        expect(normalized.onload).toBeNull();
+      });
+    });
+    
+    describe("given a klass value", function() {
+      beforeEach(function() { normalized = Jax.Util.normalizeOptions({k:new (Jax.Class.create({}))}, {}); });
+      
+      it("should be an instance of that klass", function() {
+        expect(normalized.k.klass).not.toBeUndefined();
+        expect(normalized.k).toBeKindOf(normalized.k.klass);
+      });
+    });
+    
+    describe("given values that are not in defaults", function() {
+      beforeEach(function() { normalized = Jax.Util.normalizeOptions({m:8,n:{o:9,p:0}}, {i:1,j:{k:2,l:3}}); });
+      
+      it("should contain defaults", function() {
+        expect(normalized.i).toEqual(1);
+        expect(normalized.j.k).toEqual(2);
+        expect(normalized.j.l).toEqual(3);
+      });
+      
+      it("should contain customs", function() {
+        expect(normalized.m).toEqual(8);
+        expect(normalized.n.o).toEqual(9);
+        expect(normalized.n.p).toEqual(0);
+      });
+    });
+    
+    describe("given values that override defaults", function() {
+      beforeEach(function() { normalized = Jax.Util.normalizeOptions({i:8,j:{k:9,l:0}}, {i:1,j:{k:2,l:3}}); });
+      
+      it("should copy overrides", function() {
+        expect(normalized.i).toEqual(8);
+        expect(normalized.j.k).toEqual(9);
+        expect(normalized.j.l).toEqual(0);
+      });
+    });
+    
+    describe("given undefined", function() {
+      beforeEach(function() { normalized = Jax.Util.normalizeOptions(undefined, {i:1,j:{k:2,l:3}}); });
+      
+      it("should copy defaults", function() {
+        expect(normalized.i).toEqual(1);
+      });
+      
+      it("should copy nested defaults", function() {
+        expect(normalized.j.k).toEqual(2);
+        expect(normalized.j.l).toEqual(3);
+      })
+    });
+  });
+});

data/spec/javascripts/jax/geometry/line_spec.js

@@ -0,0 +1,20 @@
+describe("Jax.Geometry.Line", function() {
+  var line;
+  
+  beforeEach(function() { line = new Jax.Geometry.Line(); });
+  
+  it("should delegate index accessors", function() {
+    expect(line[0]).toBe(line.a);
+    expect(line[1]).toBe(line.b);
+    expect(line[2]).toBeUndefined();
+  });
+  
+  it("should return itself from #set", function() {
+    expect(line.set([0,0,0], [1,1,1])).toBe(line);
+  });
+  
+  it("should calculate length", function() {
+    line.set([1,1,0], [2,2,0]);
+    expect(line.length).toEqual(Math.sqrt(2));
+  });
+});