jax 1.1.1 → 2.0.0

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

@@ -0,0 +1,181 @@
+describe("Jax.Geometry.Plane", function() {
+  describe("constructor", function() {
+    it("should build the same plane from point and normal as from 3 points", function() {
+      var p1 = new Jax.Geometry.Plane([0,1,0], [-1,0,0], [1,0,0]);
+      var p2 = new Jax.Geometry.Plane([0,0,0], [0,0,1]);
+      
+      expect(p1.normal).toEqualVector(p2.normal);
+      expect(p1.d).toEqual(p2.d);
+    })
+  });
+  
+  it('should be able to reconstruct itself using point and normal getters', function() {
+    var p = new Jax.Geometry.Plane([0,1,0], [-1,0,0], [1,0,0]);
+    var p2 = new Jax.Geometry.Plane(p.point, p.normal);
+    expect(p.normal).toEqualVector(p2.normal);
+    expect(p.d).toEqual(p2.d);
+  });
+  
+  describe("intersections", function() {
+    var p;
+    
+    beforeEach(function() {
+      p = new Jax.Geometry.Plane([0,1,0], [-1,0,0], [1,0,0]);
+    });
+    
+    describe("triangle", function() {
+      it("parallel", function() {
+        expect(p.intersectTriangle(new Jax.Geometry.Triangle([0,1,1], [-1,0,1], [1,0,1]))).toBeFalsy();
+      });
+
+      it("outside", function() {
+        expect(p.intersectTriangle(new Jax.Geometry.Triangle([0,0,2], [-1,0,1], [1,0,1]))).toBeFalsy();
+      });
+
+      it("intersect", function() {
+        expect(p.intersectTriangle(new Jax.Geometry.Triangle([0,0,-1], [-1,0,1], [1,0,1]))).toBeTruthy();
+      });
+      
+      it("intersect with receiver", function() {
+        var r = new Jax.Geometry.Line();
+        p.intersectTriangle(new Jax.Geometry.Triangle([0,0,-1], [-1,0,1], [1,0,1]), r);
+        expect(r.length).toBeGreaterThan(Math.EPSILON);
+      });
+    });
+    
+    describe("plane", function() {
+      it("disjoint (no intersect)", function() {
+        var p2 = new Jax.Geometry.Plane([0,1,1], [-1,0,1], [1,0,1]);
+        expect(p.intersectPlane(p2)).toBeFalsy();
+      });
+      
+      it("coincide", function() {
+        var p2 = new Jax.Geometry.Plane([0,1,0], [-1,0,0], [1,0,0]);
+        expect(p.intersectPlane(p2)).toEqual(Jax.Geometry.COINCIDE);
+      });
+      
+      it("intersect", function() {
+        var p2 = new Jax.Geometry.Plane([0,0,1], [-1,0,0], [1,0,0]);
+        expect(p.intersectPlane(p2)).toEqual(Jax.Geometry.INTERSECT);
+      });
+      
+      it("intersect line", function() {
+        var p2 = new Jax.Geometry.Plane([0,0,1], [-1,0,0], [1,0,0]);
+        var line = new Jax.Geometry.Line();
+        p.intersectPlane(p2, line);
+        expect(line[0]).toEqualVector([ 0,0,0]);
+        expect(line[1]).toEqualVector([ 1,0,0]);
+      });
+    });
+    
+    describe("ray", function() {
+      it("parallel should not intersect", function() {
+        expect(p.intersectRay([0,0,1], [1,0,0])).toBeFalsy();
+      });
+      
+      it("from the front", function() {
+        expect(p.intersectRay([0,0,1], [0,0,-1])).toEqual(1);
+      });
+      
+      it("from behind", function() {
+        expect(p.intersectRay([0,0,-1],[0,0, 1])).toEqual(1);
+      });
+
+      it("pointing away", function() {
+        expect(p.intersectRay([0,0,-1],[0,0,-1])).toEqual(-1);
+      });
+    });
+
+    describe("line segment", function() {
+      it("store intersection point", function() {
+        var i = vec3.create();
+        p.intersectLineSegment(new Jax.Geometry.Line([0,0,1], [0,0,-1]), i);
+        expect(i).toEqualVector([0,0,0]);
+      });
+      
+      it("parallel", function() {
+        expect(p.intersectLineSegment(new Jax.Geometry.Line([0,0,1], [1,0,1]))).toBeFalsy();
+      });
+      
+      it("coincident", function() {
+        expect(p.intersectLineSegment(new Jax.Geometry.Line([0,0,0], [0.5,0,0]))).toEqual(Jax.Geometry.COINCIDE);
+      });
+      
+      it("from the front", function() {
+        expect(p.intersectLineSegment(new Jax.Geometry.Line([0,0,1], [0,0,-1]))).toEqual(Jax.Geometry.INTERSECT);
+      });
+      
+      it("from behind", function() {
+        expect(p.intersectLineSegment(new Jax.Geometry.Line([0,0,-1],[0,0, 1]))).toEqual(Jax.Geometry.INTERSECT);
+      });
+
+      it("pointing away", function() {
+        expect(p.intersectLineSegment(new Jax.Geometry.Line([0,0,-1],[0,0,-2]))).toEqual(Jax.Geometry.DISJOINT);
+      });
+    });
+  });
+  
+  it("distance", function() {
+    var p = new Jax.Geometry.Plane([0,1,0], [-1,0,0], [1,0,0]);
+    expect(p.distance([0,0, 2])).toEqual(2);
+    expect(p.distance([0,0,-2])).toEqual(-2);
+    expect(p.distance([0,0, 0])).toEqual(0);
+
+    var region = new Jax.DataRegion();
+    var data = region.map(Float32Array, [0,0,2,  0,0,-2,  0,0,0]);
+    var vertices = data.group(3);
+    expect(p.distance(vertices[0])).toEqual(2);
+    expect(p.distance(vertices[1])).toEqual(-2);
+    expect(p.distance(vertices[2])).toEqual(0);
+  });
+  
+  it("whereis", function() {
+    var p = new Jax.Geometry.Plane([0,1,0], [-1,0,0], [1,0,0]);
+    expect(p.whereis([0,0, 2])).toEqual(Jax.Geometry.Plane.FRONT);
+    expect(p.whereis([0,0,-2])).toEqual(Jax.Geometry.Plane.BACK);
+    expect(p.whereis([0,0, 0])).toEqual(Jax.Geometry.Plane.INTERSECT);
+    
+    var region = new Jax.DataRegion();
+    var data = region.map(Float32Array, [0,0,2,  0,0,-2,  0,0,0]);
+    var vertices = data.group(3);
+    expect(p.whereis(vertices[0])).toEqual(Jax.Geometry.Plane.FRONT);
+    expect(p.whereis(vertices[1])).toEqual(Jax.Geometry.Plane.BACK);
+    expect(p.whereis(vertices[2])).toEqual(Jax.Geometry.Plane.INTERSECT);
+  });
+  
+  describe("construction", function() {
+    it("with no vertices", function() {
+      var p = new Jax.Geometry.Plane();
+      expect(p.normal).toEqualVector([0,1,0]);
+      expect(p.d).toEqual(0);
+    });
+
+    it('with a vertex array', function() {
+      var p = new Jax.Geometry.Plane([[0,1,0], [-1,0,0], [1,0,0]]);
+      expect(p.normal).toEqualVector([0,0,1]);
+      expect(p.d).toEqual(0);
+    });
+
+    it('with a 3x3 data segment', function() {
+      var region = new Jax.DataRegion();
+      var data = region.map(Float32Array, [0,1,0,  -1,0,0,  1,0,0]);
+      var vertices = data.group(3);
+      var p = new Jax.Geometry.Plane(vertices);
+      expect(p.normal).toEqualVector([0,0,1]);
+      expect(p.d).toEqual(0);
+    });
+
+    it("with vertices", function() {
+      var p = new Jax.Geometry.Plane([0,1,0], [-1,0,0], [1,0,0]);
+      expect(p.normal).toEqualVector([0,0,1]);
+      expect(p.d).toEqual(0);
+    });
+  });
+  
+  it("set coefficients", function() {
+    var p = new Jax.Geometry.Plane();
+    p.setCoefficients(0, 2, 0, 1);
+    expect(p.normal).toEqualVector([0,1,0]);
+    expect(p.d).toEqual(0.5);
+  });
+});

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

@@ -0,0 +1,105 @@
+describe("Jax.Geometry.Triangle", function() {
+  describe("intersections", function() {
+    describe("triangle", function() {
+      var tri;
+    
+      beforeEach(function() {
+        tri = new Jax.Geometry.Triangle([0,0,0], [-1,0,0], [0,1,0]);
+      });
+    
+      describe("with triangle", function() {
+        // more complete tritri tests found in tritri_spec.js
+        it("no intersect", function() {
+          var tri2 = new Jax.Geometry.Triangle([0,0.5,2],[-1,0.5,2],[0,1.5,2]);
+          expect(tri.intersectTriangle(tri2)).toBeFalsy();
+        });
+
+        it("intersect", function() {
+          var tri2 = new Jax.Geometry.Triangle([0,0.95,-1],[-1,0.95,2],[1,0.95,2]);
+          expect(tri.intersectTriangle(tri2)).toBeTruthy();
+        });
+        
+        it("identical, positioned above", function() {
+          tri = new Jax.Geometry.Triangle([0,0.95,-1],[-1,0.95,2],[1,0.95,2]);
+          var tri2 = new Jax.Geometry.Triangle([0,3.95,-1],[-1,3.95,2],[1,3.95,2]);
+
+          expect(tri.intersectTriangle(tri2)).toBeFalsy();
+        });
+      });
+    
+      describe("with triangle and capture point", function() {
+        var line;
+        beforeEach(function() { line = new Jax.Geometry.Line(); });
+        
+        // more complete tritri tests found in tritri_spec.js
+        it("no intersect", function() {
+          var tri2 = new Jax.Geometry.Triangle([0,0.5,2],[-1,0.5,2],[0,1.5,2]);
+          expect(tri.intersectTriangle(tri2, line)).toBeFalsy();
+        });
+
+        it("intersect", function() {
+          var tri2 = new Jax.Geometry.Triangle([0,0.95,-1],[-1,0.95,2],[1,0.95,2]);
+          expect(tri.intersectTriangle(tri2, line)).toBeTruthy();
+          expect(Math.abs(line.a[0]) + Math.abs(line.a[1]) + Math.abs(line.a[2])).toBeGreaterThan(Math.EPSILON);
+        });
+        
+        it("identical, positioned above", function() {
+          tri = new Jax.Geometry.Triangle([0,0.95,-1],[-1,0.95,2],[1,0.95,2]);
+          var tri2 = new Jax.Geometry.Triangle([0,3.95,-1],[-1,3.95,2],[1,3.95,2]);
+
+          expect(tri.intersectTriangle(tri2, line)).toBeFalsy();
+        });
+      });
+    
+      describe("with ray", function() {
+        it("intersect", function() {
+          var O = [0,0,1];
+          var D = [0,0,-1];
+          var cp = [];
+          var segmax = 2;
+        
+          expect(tri.intersectRay(O, D, cp, segmax)).toBeTruthy();
+          // it intersects at [0,0,0], where distance from [0,0,-1] is 1
+          expect(cp).toEqualVector([0,0,0,1]);
+        });
+      
+        it("no intersect", function() {
+          var O = [1,0,0];
+          var D = [0,0,-1];
+          var cp = [];
+          var segmax = 2;
+        
+          expect(tri.intersectRay(O, D, cp, segmax)).toBeFalsy();
+        });
+      });
+
+      describe("with sphere", function() {
+        it("interior intersect", function() {
+          var O = [-2,0,0];
+          var radius = 1;
+          var cp = [];
+        
+          expect(tri.intersectSphere(O, radius, cp)).toBeTruthy();
+          expect(cp).toEqualVector([-1,0,0]);
+        });
+      
+        it("edge intersect", function() {
+          var O = [1,0.5,0];
+          var radius = 1;
+          var cp = [];
+        
+          expect(tri.intersectSphere(O, radius, cp)).toBeTruthy();
+          expect(cp).toEqualVector([0,0.5,0]);
+        });
+      
+        it("no intersect", function() {
+          var O = [2, 0.5, 0];
+          var radius = 1;
+          var cp = [];
+
+          expect(tri.intersectSphere(O, radius, cp)).toBeFalsy();
+        });
+      });
+    });
+  });
+});

data/spec/javascripts/jax/mvc/controller_spec.js

@@ -0,0 +1,156 @@
+describe("Jax.Controller", function() {
+  var klass;
+  var instance;
+  
+  it("should map a default view", function() {
+    Jax.views.remove("welcome/index");
+    Jax.Controller.create("welcome", {});
+    expect(Jax.views.find("welcome/index")).not.toBeUndefined();
+  });
+  
+  describe("with an update method", function() {
+    var context;
+    
+    beforeEach(function() {
+      klass = Jax.Controller.create("welcome", { index: function() { }, update: function(tc) { } });
+      Jax.views.push("welcome/index", function() { });
+      Jax.routes.map("welcome", klass);
+      context = new Jax.Context(SPEC_CONTEXT.canvas);
+      instance = context.redirectTo("welcome");
+      spyOn(instance, 'update');
+    });
+    
+    afterEach(function() { context.dispose(); });
+    
+    it("should be called when the context is updated", function() {
+      /*
+        we can't really register a callback to setTimeout and check that it was called automatically,
+        so we'll have to simulate it by calling Context#update() directly.
+       */
+      context.update();
+      expect(instance.update).toHaveBeenCalled();
+    });
+  });
+
+  describe("which does not render or redirect", function() {
+    beforeEach(function() {
+      klass = Jax.Controller.create("welcome", { index: function() { } });
+      instance = new klass();
+    });
+    
+    it("should produce the view named after the controller and action names", function() {
+      instance.fireAction("index");
+      expect(instance.view_key).toEqual("welcome/index");
+    });
+    
+    it("should map the route automatically", function() {
+      expect(function() { Jax.routes.recognizeRoute("welcome/index") }).not.toThrow();
+    });
+  });
+
+  describe("with event actions", function() {
+    beforeEach(function() {
+      klass = Jax.Controller.create("welcome", { index: function() { } });
+      instance = new klass();
+    });
+
+    var evt;
+
+    function doMouseEvent(type) {
+      /* MouseEvents - click, mousedown, mousemove, mouseout, mouseover, mouseup */
+      /* initMouseEvent - type, bubbles, cancelable, windowObject, detail, screenX, screenY, clientX, clientY, ctrlKey,
+       * altKey, shiftKey, metaKey, button, relatedTarget */
+      evt = document.createEvent('MouseEvents');
+      evt.initMouseEvent(type, true, true, Jax.getGlobal(), 1, 0, 0, 0, 0, false, false, false, false, 0, null);
+      SPEC_CONTEXT.canvas.dispatchEvent(evt);
+    }
+
+    function doKeyEvent(type) {
+      /* UIEvents - DOMActivate, DOMFocusIn, DOMFocusOut */
+      /* KeyEvents / UIEvents - keydown, keypress, keyup */
+      /* initUIEvent - type, bubbles, cancelable windowObject, detail */
+      if (Jax.getGlobal().KeyEvent && !KeyEvent.fake) {
+        evt = document.createEvent('KeyEvents');
+        // type, bubbles, cancelable, windowObject, ctrlKey, altKey, shiftKey, metaKey, keyCode, charCode
+        evt.initKeyEvent(type, true, true, Jax.getGlobal(), false, false, false, false, 13, 0);
+      } else {
+        evt = document.createEvent('UIEvents');
+        evt.initUIEvent(type, true, true, Jax.getGlobal(), 1);
+        evt.keyCode = 13;
+      }
+      SPEC_CONTEXT.canvas.dispatchEvent(evt);
+    }
+
+    beforeEach(function() {
+      var methods = {
+        mouse_clicked:  function(evt) { },
+        mouse_moved:    function(evt) { },
+        mouse_dragged:  function(evt) { },
+        mouse_pressed:  function(evt) { },
+        mouse_exited:   function(evt) { },
+        mouse_entered:  function(evt) { },
+        mouse_released: function(evt) { },
+        key_typed:      function(evt) { },
+        key_pressed:    function(evt) { },
+        key_released:   function(evt) { }
+      };
+      klass.addMethods(methods);
+      expect(instance).toHaveMethod("mouse_clicked"); // verify methods were added
+      for (var method_name in methods) spyOn(instance, method_name);
+      Jax.routes.clear();
+      SPEC_CONTEXT.current_controller = instance;
+      SPEC_CONTEXT.registerMouseListeners(instance);
+      SPEC_CONTEXT.registerKeyListeners(instance);
+    });
+
+    it("should dispatch key pressed events", function() {
+      doKeyEvent('keypress');
+      expect(instance.key_typed).toHaveBeenCalled();
+    });
+
+    it("should dispatch key released events", function() {
+      doKeyEvent('keyup');
+      expect(instance.key_released).toHaveBeenCalled();
+    });
+
+    it("should dispatch key down events", function() {
+      doKeyEvent('keydown');
+      expect(instance.key_pressed).toHaveBeenCalled();
+    });
+
+    it("should dispatch mouse released events", function() {
+      doMouseEvent('mouseup');
+      expect(instance.mouse_released).toHaveBeenCalled();
+    });
+    it("should dispatch mouse entered events", function() {
+      doMouseEvent('mouseout');
+      expect(instance.mouse_exited).toHaveBeenCalled();
+    });
+    it("should dispatch mouse exited events", function() {
+      doMouseEvent('mouseover');
+      expect(instance.mouse_entered).toHaveBeenCalled();
+    });
+
+    it("should dispatch mouse pressed events", function() {
+      doMouseEvent('mousedown');
+      expect(instance.mouse_pressed).toHaveBeenCalled();
+    });
+
+    it("should dispatch mouse dragged events", function() {
+      doMouseEvent('mousedown');
+      doMouseEvent('mousemove');
+      doMouseEvent('mouseup');
+      expect(instance.mouse_dragged).toHaveBeenCalled();
+    });
+
+    it("should dispatch mouse moved events", function() {
+      doMouseEvent('mousemove');
+      expect(instance.mouse_moved).toHaveBeenCalled();
+    });
+
+    it("should dispatch mouse clicked events", function() {
+      doMouseEvent('click');
+      expect(instance.mouse_clicked).toHaveBeenCalled();
+    });
+  });
+});

data/spec/javascripts/jax/mvc/model_spec.js

@@ -0,0 +1,93 @@
+describe("Jax.Model", function() {
+  var model;
+  
+  describe("as a resource", function() {
+    // do these things only once, because we're going to see how one model instance interacts with another
+    var klass, res_data = { "name": {one: { value : 1 } } };
+    klass = Jax.Model.create({});
+    klass.addResources(res_data);
+
+    beforeEach(function() {
+      model = klass.find("name");
+    });
+    
+    it("should find new resource instances instead of existing ones", function() {
+      model.two = 2;
+      model = klass.find("name");
+      expect(model.two).toBeUndefined();
+    });
+    
+    it("should not alter the original resource data", function() {
+      model.one.value = 2;
+      model = klass.find("name");
+      expect(model.one.value).not.toEqual(2);
+    });
+  });
+  
+  describe("added to world without a mesh", function() {
+    beforeEach(function() { model = new (Jax.Model.create({after_initialize:function(){}}))({position:[0,0,0]}); SPEC_CONTEXT.world.addObject(model); });
+    
+    it("should not cause errors when rendering", function() {
+      expect(function() { SPEC_CONTEXT.world.render(); }).not.toThrow();
+    });
+  });
+    
+  describe("without any custom methods", function() {
+    beforeEach(function() {
+      model = Jax.Model.create({
+        initialize: function($super, data) { $super(Jax.Util.normalizeOptions(data, {mesh:new Jax.Mesh.Quad()})); }
+      });
+    });
+    
+    describe("instantiated", function() {
+      beforeEach(function() { model = new model(); });
+      
+      describe("that is not a shadowcaster", function() {
+        beforeEach(function() { model.shadow_caster = false; });
+        it("should still be lit", function() { expect(model).toBeIlluminated(); });
+      });
+
+      describe("that is not lit", function() {
+        beforeEach(function() { model.lit = false; });
+        it("should not be rendered in illumination pass", function() {
+          expect(model).not.toBeIlluminated();
+        });
+      });
+
+      it("should render properly", function() {
+        model.render(SPEC_CONTEXT);
+      });
+    });
+  
+    it("should fire after_initialize", function() {
+      model.addResources({ "name": { fired: false } });
+      model.addMethods({ after_initialize: function() { this.fired = true; } });
+      expect(model.find("name").fired).toBeTrue();
+    });
+    
+    it("should raise an error when searching for a missing ID", function() {
+      model.addResources({"one": { } });
+      expect(function() { model.find("two") }).toThrow(new Error("Resource 'two' not found!"));
+    });
+    
+    it("should assign default attribute values", function() {
+      model.addResources({'default':{one:'one'},'name':{two:'two'}});
+      expect(model.find('name').one).toEqual("one");
+      expect(model.find('name').two).toEqual("two");
+    });
+
+    it("should assign attribute values", function() {
+      model.addResources({ "name": { one: "one" } });
+      expect(model.find("name").one).toEqual("one");
+    });
+  
+    it("should instantiate a model that is missing default attributes", function() {
+      expect(function() { new model(); }).not.toThrow();
+    });
+  });
+  
+  describe("with a custom method", function() {
+    beforeEach(function() { model = Jax.Model.create({method: function() { return "called"; } }); });
+    it("should work", function() { expect(new model().method()).toEqual("called"); });
+  });
+});

data/spec/javascripts/jax/mvc/route_set_spec.js

@@ -0,0 +1,49 @@
+describe("Jax.RouteSet", function() {
+  var map;
+  var controller_class = Jax.Controller.create({index: function() { }});
+  Jax.views.push("generic/index", function() { });
+  
+  beforeEach(function() { map = Jax.routes; map.clear(); });
+  
+  describe("when a controller name is given during controller definition", function() {
+    beforeEach(function() {
+      controller_class = Jax.Controller.create("welcome", {index: function() { }});
+    });
+    
+    it("should map routes automatically", function() {
+      var route = map.recognizeRoute("welcome");
+      expect(route.controller).toEqual(controller_class);
+      expect(route.action).toEqual("index");
+    });
+    
+    it("should automatically map actions added after controller is defined", function() {
+      controller_class.prototype.other = function() { };
+      var route = map.recognizeRoute("welcome/other");
+      expect(route.controller).toEqual(controller_class);
+      expect(route.action).toEqual("other");
+    });
+
+    it("should return the controller name in an array", function() {
+      var arr = map.getControllerNames();
+      expect(arr.length).toEqual(1);
+      expect(arr[0]).toEqual("welcome");
+    });
+  });
+  
+  describe("with a map", function() {
+    beforeEach(function() { map.map("generic/index", controller_class, "index"); });
+    
+    it("should recognize the route without /index", function() {
+      var route = map.recognizeRoute("generic");
+      
+      expect(route.controller).toEqual(controller_class);
+      expect(route.action).toEqual("index");
+    });
+    
+    it("should return the controller name in an array", function() {
+      var arr = map.getControllerNames();
+      expect(arr.length).toEqual(1);
+      expect(arr[0]).toEqual("generic");
+    });
+  });
+});

data/spec/javascripts/jax/mvc/view_manager_spec.js

@@ -0,0 +1,17 @@
+describe("Jax.ViewManager", function() {
+  var views;
+  
+  beforeEach(function() { views = new Jax.ViewManager(); });
+  
+  describe("with one registered view", function() {
+    beforeEach(function() { views.push("controller/action", function() { }); });
+    
+    it("should return the registered view", function() {
+      expect(views.get("controller/action")).toBeKindOf(Jax.View);
+    });
+    
+    it("should throw an error when requesting a missing view", function() {
+      expect(function() { return views.get("missing/action"); }).toThrow(new Error("Could not find view at 'missing/action'!"));
+    });
+  });
+});

data/spec/javascripts/jax/noise_spec.js

@@ -0,0 +1,50 @@
+describe("Jax.Noise", function() {
+  var noise, uniforms;
+  
+  beforeEach(function() {
+    uniforms = { texture:function(name, tex, context) { }, set: function(name, value) { } };
+    spyOn(uniforms, 'set');
+    spyOn(uniforms, 'texture');
+  });
+  
+  describe("initialized without a context", function() {
+    beforeEach(function() { noise = new Jax.Noise(); });
+    
+    it("should not be prepared for use", function() {
+      //because we never gave it a context to prepare against
+      expect(noise.isPrepared(SPEC_CONTEXT)).toBeFalsy();
+    });
+    
+    it("should bind to a uniform delegator and be prepared", function() {
+      // is this too brittle?
+      noise.bind(SPEC_CONTEXT, uniforms);
+      expect(uniforms.texture).toHaveBeenCalledWith('permTexture',    noise.perm,    SPEC_CONTEXT);
+      expect(uniforms.texture).toHaveBeenCalledWith('gradTexture',    noise.grad,    SPEC_CONTEXT);
+      expect(uniforms.texture).toHaveBeenCalledWith('simplexTexture', noise.simplex, SPEC_CONTEXT);
+      expect(noise.isPrepared(SPEC_CONTEXT)).toBeTruthy();
+    });
+  });
+  
+  describe("initialized old-style, with a context", function() {
+    beforeEach(function() {
+      noise = new Jax.Noise(SPEC_CONTEXT);
+    });
+
+    it("should be prepared for use", function() {
+      expect(noise.isPrepared(SPEC_CONTEXT)).toBeTruthy();
+
+      // make the same assertion with a dummy context, to make sure noise isn't lying about its preparedness
+      var dummy_context = {id:-10};
+      expect(noise.isPrepared(dummy_context)).toBeFalsy();
+    });
+    
+    it("should bind to a uniform delegator and be prepared", function() {
+      // is this too brittle?
+      noise.bind(SPEC_CONTEXT, uniforms);
+      expect(uniforms.texture).toHaveBeenCalledWith('permTexture',    noise.perm,    SPEC_CONTEXT);
+      expect(uniforms.texture).toHaveBeenCalledWith('gradTexture',    noise.grad,    SPEC_CONTEXT);
+      expect(uniforms.texture).toHaveBeenCalledWith('simplexTexture', noise.simplex, SPEC_CONTEXT);
+      expect(noise.isPrepared(SPEC_CONTEXT)).toBeTruthy();
+    });
+  });
+});