jax 1.1.1 → 2.0.0

data/spec/javascripts/jax/world_spec.js

@@ -0,0 +1,175 @@
+describe("Jax.World", function() {
+  var world;
+  
+  beforeEach(function() {
+    s = this.suite;
+    d = s.description;
+    while (s) {
+      s = s.parentSuite;
+      if (s) d = s.description + " " + d;
+    }
+    console.log(d);
+    
+    SPEC_CONTEXT.prepare();
+    world = SPEC_CONTEXT.world;
+  });
+  
+  describe("picking", function() {
+    var at, ofront, otopleft, otopright, obottomleft, obottomright, mesh;
+    
+    beforeEach(function() {
+      var width = SPEC_CONTEXT.canvas.width,
+          height = SPEC_CONTEXT.canvas.height;
+      at = { left: 0, right: width-1, top: height-1, bottom: 0,
+             center_x: parseInt(width/2), center_y: parseInt(height/2) };
+
+      // put some objects in the world for picking
+      // function mesh() { return new Jax.Mesh.Sphere({size:1.0}); }
+      
+      mesh = new Jax.Mesh.Sphere();
+      ofront       = world.addObject(new Jax.Model({position:[ 0.0, 0.0, -5],mesh:mesh}));
+      otopleft     = world.addObject(new Jax.Model({position:[-2.5, 2.5, -5],mesh:mesh}));
+      otopright    = world.addObject(new Jax.Model({position:[ 2.5, 2.5, -5],mesh:mesh}));
+      obottomleft  = world.addObject(new Jax.Model({position:[-2.5,-2.5, -5],mesh:mesh}));
+      obottomright = world.addObject(new Jax.Model({position:[ 2.5,-2.5, -5],mesh:mesh}));
+    });
+    
+    it("center",       function() { expect(world.pick(at.center_x, at.center_y)).toEqual(ofront); });
+    it("top left",     function() { expect(world.pick(at.left, at.top)).toEqual(otopleft); });
+    it("top right",    function() { expect(world.pick(at.right,at.top)).toEqual(otopright); });
+    it("bottom left",  function() { expect(world.pick(at.left, at.bottom)).toEqual(obottomleft); });
+    it("bottom right", function() { expect(world.pick(at.right,at.bottom)).toEqual(obottomright); });
+    /*
+    it("region: everything", function() {
+      var objects = world.pickRegion(at.left, at.top, at.right, at.bottom);
+      expect(objects).toContain(ofront);
+      expect(objects).toContain(otopleft);
+      expect(objects).toContain(otopright);
+      expect(objects).toContain(obottomleft);
+      expect(objects).toContain(obottomright);
+    });
+    
+    it("region: top-left quadrant", function() {
+      var objects = world.pickRegion(at.left, at.top, at.center_x, at.center_y);
+      expect(objects).toContain(ofront);
+      expect(objects).toContain(otopleft);
+      expect(objects).not.toContain(otopright);
+      expect(objects).not.toContain(obottomleft);
+      expect(objects).not.toContain(obottomright);
+    });
+
+    it("region: top-right quadrant", function() {
+      var objects = world.pickRegion(at.right, at.top, at.center_x, at.center_y);
+      expect(objects).toContain(ofront);
+      expect(objects).not.toContain(otopleft);
+      expect(objects).toContain(otopright);
+      expect(objects).not.toContain(obottomleft);
+      expect(objects).not.toContain(obottomright);
+    });
+
+    it("region: bottom-left quadrant", function() {
+      var objects = world.pickRegion(at.left, at.bottom, at.center_x, at.center_y);
+      expect(objects).toContain(ofront);
+      expect(objects).not.toContain(otopleft);
+      expect(objects).not.toContain(otopright);
+      expect(objects).toContain(obottomleft);
+      expect(objects).not.toContain(obottomright);
+    });
+    
+    it("region: bottom-right quadrant", function() {
+      var objects = world.pickRegion(at.right, at.bottom, at.center_x, at.center_y);
+      expect(objects).toContain(ofront);
+      expect(objects).not.toContain(otopleft);
+      expect(objects).not.toContain(otopright);
+      expect(objects).not.toContain(obottomleft);
+      expect(objects).toContain(obottomright);
+    });
+    */
+  });
+  
+  describe("with an object", function() {
+    beforeEach(function() { world.addObject(new Jax.Model()); });
+    
+    it("should remove the object", function() {
+      world.removeObject(world.getObject(0));
+      expect(world.countObjects()).toEqual(0);
+    });
+  });
+  
+  describe("with lighting disabled", function() {
+    beforeEach(function() { world.lighting.disable(); });
+    
+    // we no longer switch materials in Jax.World depending on lighting. "Basic" and "default" are the same, now.
+    xit("should default to the 'basic' material", function() {
+      var model = new Jax.Model();
+      world.addObject(model);
+      expect(model).toDefaultToMaterial("basic", world);
+      world.render();
+    });
+  });
+  
+  describe("adding a light source from a string", function() {
+    beforeEach(function() {
+      Jax.Scene.LightSource.addResources({"test":{}});
+      world.addLightSource("test");
+    });
+    
+    it("should find the light source automatically", function() {
+      expect(world.lighting.getLight(0)).toBeKindOf(Jax.Scene.LightSource);
+    });
+  });
+
+  describe("with lighting enabled", function() {
+    beforeEach(function() { world.addLightSource(new Jax.Scene.LightSource({type:Jax.DIRECTIONAL_LIGHT})); });
+    
+    it("should default to the 'default' material", function() {
+      var model = new Jax.Model({mesh:new Jax.Mesh.Quad()});
+      world.addObject(model);
+      expect(model).toDefaultToMaterial('default', world);
+    });
+    
+    xit("should use the 'default' material", function() {
+      var model = new Jax.Model({mesh:new Jax.Mesh.Quad()});
+      world.addObject(model);
+      expect(model).toUseMaterial('default', world);
+    });
+    
+    describe("but the object unlit", function() {
+      var model;
+      
+      beforeEach(function() {
+        // notice the explicit use of "basic" here. This is so we can test that explicit "basic" types
+        // get rendered as such, instead of simply being chucked into the "lighting is enabled, use blinn-phong"
+        // category.
+        model = new Jax.Model({mesh:new Jax.Mesh.Quad({material:"basic",color:[0.5,0.5,0.5,1]}), lit:false });
+      });
+      
+      describe("and unshadowed", function() {
+        beforeEach(function() {
+          model = new Jax.Model({mesh:new Jax.Mesh.Quad(), shadow_caster: false, lit:false});
+        });
+        
+        xit("should use basic material", function() {
+          world.addObject(model);
+          expect(model).toUseMaterial('basic', world);
+        });
+        
+        it("should not cast a shadow", function() {
+          world.addObject(model);
+          expect(model).not.toCastShadow(world);
+        });
+      });
+      
+      it("should still cast a shadow", function() {
+        world.addObject(model);
+        expect(world.getShadowCasters()).toContain(model);
+        expect(model).toCastShadow(world);
+      });
+      
+      xit("should be rendered with basic material", function() {
+        world.addObject(model);
+        expect(model).toUseMaterial('basic', world);
+      });
+    });
+  });
+});

data/spec/javascripts/jax_spec.js

@@ -0,0 +1,14 @@
+describe("Jax", function() {
+  it("should be loaded", function() {
+    /* if false, then it didn't load all of the Jax libraries successfully */
+    expect(Jax.loaded).toBeTrue();
+  });
+  
+  it("should create the top-level view container", function() {
+    expect(Jax.views).not.toBeUndefined();
+  });
+  
+  it("should initialize the route set", function() {
+    expect(Jax.routes).not.toBeUndefined();
+  });
+});

data/spec/javascripts/node/mocks/webgl.js

@@ -0,0 +1,159 @@
+// it's a function so that we can initialize a new context for each spec
+// that way specs don't taint each other
+exports.context = (function() { return {
+  fake: true,
+  
+  getParameter: function() { return 32; },
+  clearColor: function() { },
+  getError: function() { return this.NO_ERROR; },
+  clearDepth: function() { },
+  enable: function() { },
+  disable: function() { },
+  depthFunc: function() { },
+  blendFunc: function() { },
+  viewport: function() { },
+  cullFace: function() { },
+  polygonOffset: function() { },
+  createFramebuffer: function() { return {}; },
+  bindFramebuffer: function() { },
+  createRenderbuffer: function() { return {}; },
+  bindRenderbuffer: function() { },
+  renderbufferStorage: function() { },
+  createProgram: function() { return {}; },
+  createShader: function() { return {}; },
+  attachShader: function() { },
+  shaderSource: function() { },
+  compileShader: function() { },
+  getShaderParameter: function() { return {}; },
+  getShaderInfoLog: function() { return ""; },
+  linkProgram: function() { },
+  getProgramParameter: function() { return {}; },
+  useProgram: function() { },
+  drawArrays: function() { },
+  framebufferRenderbuffer: function() { },
+  createTexture: function() { return {}; },
+  bindTexture: function() { },
+  texImage2D: function() { },
+  texParameteri: function() { },
+  pixelStorei: function() { },
+  framebufferTexture2D: function() { },
+  checkFramebufferStatus: function() { return this.FRAMEBUFFER_COMPLETE; },
+  clear: function() { },
+  createBuffer: function() { return {}; },
+  bindBuffer: function() { },
+  bufferData: function() { },
+  drawElements: function() { },
+  readPixels: function() { return []; },
+  activeTexture: function() { },
+  bindTexture: function() { },
+  getProgramInfoLog: function() { return ""; },
+  getActiveUniform: function() { return {length:1,size:1,type:1,name:"unif"}; },
+  getUniformLocation: function() { return {}; },
+  
+  TRIANGLES: 1,
+  TRIANGLE_STRIP: 2,
+  POINTS: 3,
+  TRIANGLE_FAN: 4,
+  LINEAR: 5,
+  CLAMP_TO_EDGE: 12,
+  NEAREST: 7,
+  DONT_CARE: 8,
+  RGBA: 9,
+  TEXTURE_2D: 10,
+  UNSIGNED_BYTE: 11,
+  REPEAT: 6,
+  BLEND: 13,
+  SRC_ALPHA: 14,
+  ONE_MINUS_SRC_ALPHA: 15,
+  NO_ERROR: 16,
+  DEPTH_TEST: 17,
+  LEQUAL: 18,
+  ARRAY_BUFFER: 19,
+  STATIC_DRAW: 20,
+  CULL_FACE: 21,
+  FRONT: 22,
+  BACK: 23,
+  POLYGON_OFFSET_FILL: 24,
+  FRAMEBUFFER: 25,
+  RENDERBUFFER: 26,
+  DEPTH_COMPONENT16: 27,
+  VERTEX_SHADER: 28,
+  FRAGMENT_SHADER: 29,
+  COMPILE_STATUS: 30,
+  LINK_STATUS: 31,
+  ACTIVE_ATTRIBUTES: 32,
+  ACTIVE_UNIFORMS: 33,
+  DEPTH_ATTACHMENT: 34,
+  COLOR_ATTACHMENT0: 35,
+  ALPHA: 36,
+  LUMINANCE: 37,
+  MAX_VARYING_VECTORS: 38,
+  MAX_UNIFORM_VECTORS: 39,
+  MAX_VERTEX_UNIFORM_VECTORS: 40,
+  MAX_FRAGMENT_UNIFORM_VECTORS: 41,
+  MAX_VERTEX_ATTRIBS: 42,
+  MAX_VERTEX_TEXTURE_IMAGE_UNITS: 43,
+  RGB: 44,
+  TEXTURE_MAG_FILTER: 45,
+  TEXTURE_MIN_FILTER: 46,
+  TEXTURE_WRAP_S: 47,
+  TEXTURE_WRAP_T: 48,
+  UNPACK_FLIP_Y_WEBGL: 49,
+  ELEMENT_ARRAY_BUFFER: 50,
+  UNPACK_PREMULTIPLY_ALPHA_WEBGL: 51,
+  UNPACK_COLORSPACE_CONVERSION_WEBGL: 52,
+  BROWSER_DEFAULT_WEBGL: 53,
+  FRAMEBUFFER_COMPLETE: 54,
+  FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 55,
+  FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 56,
+  FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 57,
+  FRAMEBUFFER_UNSUPPORTED: 58,
+  COLOR_BUFFER_BIT: 59,
+  DEPTH_BUFFER_BIT: 60,
+  ONE: 61,
+  STREAM_DRAW: 62,
+  UNSIGNED_SHORT: 63,
+  LUMINANCE_ALPHA: 64,
+  DEPTH_STENCIL: 65,
+  DEPTH_STENCIL_ATTACHMENT: 66,
+  TEXTURE0: 67,
+  TEXTURE1: 68,
+  TEXTURE2: 69,
+  TEXTURE3: 70,
+  TEXTURE4: 71,
+  TEXTURE5: 72,
+  TEXTURE6: 73,
+  TEXTURE7: 74,
+  TEXTURE8: 75,
+  TEXTURE9: 76,
+  TEXTURE10: 77,
+  TEXTURE11: 78,
+  TEXTURE12: 79,
+  TEXTURE13: 80,
+  TEXTURE14: 81,
+  TEXTURE15: 82,
+  TEXTURE16: 83,
+  TEXTURE17: 84,
+  TEXTURE18: 85,
+  TEXTURE19: 86,
+  TEXTURE20: 87,
+  TEXTURE21: 88,
+  TEXTURE22: 89,
+  TEXTURE23: 90,
+  TEXTURE24: 91,
+  TEXTURE25: 92,
+  TEXTURE26: 93,
+  TEXTURE27: 94,
+  TEXTURE28: 95,
+  TEXTURE29: 96,
+  TEXTURE30: 97,
+  TEXTURE31: 98,
+  TEXTURE_CUBE_MAP: 99,
+  TEXTURE_CUBE_MAP_POSITIVE_X: 100,
+  TEXTURE_CUBE_MAP_POSITIVE_Y: 101,
+  TEXTURE_CUBE_MAP_POSITIVE_Z: 102,
+  TEXTURE_CUBE_MAP_NEGATIVE_X: 103,
+  TEXTURE_CUBE_MAP_NEGATIVE_Y: 104,
+  TEXTURE_CUBE_MAP_NEGATIVE_Z: 105,
+  DYNAMIC_DRAW: 106
+}; });

data/spec/javascripts/node_helper.js

@@ -0,0 +1,51 @@
+var jsdom = require('jsdom'),
+    doc   = jsdom.jsdom('<html><body></body></html>');
+    
+global.document = doc;
+global.window = doc.createWindow();
+
+global.ENV = global.ENV || process.env;
+global.ENV['SILENCED'] = '1';
+
+/* TODO remove this when node-canvas supports webgl */
+var canvas = document._elementBuilders.canvas;
+document._elementBuilders.canvas = function(document, tagName) {
+  var element = canvas.call(this, document, tagName);
+  var getContext = element.getContext;
+  
+  element.getContext = function(name) {
+    if (name == "webgl" || name == "experimental-webgl") {
+      return require("./node/mocks/webgl.js").context();
+    } else {
+      return getContext.call(this, name);
+    }
+  };
+  
+  element.width = element.height = 100;
+  
+  return element;
+};
+
+// mock navigator
+global.navigator = {
+  userAgent: 'firefox'
+};
+
+global.Image = global.Image || function() {
+  var src;
+  
+  this.__defineGetter__("src", function() {
+    return src;
+  });
+  
+  this.__defineSetter__("src", function(s) {
+    src = s;
+    if (this.onload) this.onload();
+    return src;
+  });
+};
+
+global.Jax = require("../../tmp/jax.js").Jax;
+
+require("./helpers/jax_spec_environment_helper.js");
+setupJaxSpecContext();

data/spec/javascripts/shaders/core_materials_spec.js

@@ -0,0 +1,38 @@
+describe("Core Materials", function() {
+  var matr;
+  
+  beforeEach(function() {
+    matr = new Jax.Material();
+  });
+  
+  var mats = Jax.Material.all();
+  for (var i = 0; i < mats.length; i++) {
+    describe(mats[i], function() {
+      var name = mats[i];
+      
+      beforeEach(function() {
+        if (name != "basic" && name != "default")
+          matr.addLayer(Jax.Material.find(name));
+      });
+
+      it("should compile successfully", function() {
+        spyOn(matr, 'prepareShader').andCallThrough();
+        new Jax.Mesh({material:matr}).render(SPEC_CONTEXT);
+        expect(matr.prepareShader).toHaveBeenCalled();
+      });
+      
+      it("should coexist with all other builtins", function() {
+        var m = new Jax.Material();
+
+        if (name != "basic" && name != "default")
+          m.addLayer(Jax.Material.find(name));
+        
+        for (var j = 0; j < mats.length; j++)
+          if (mats[j] != "basic" && mats[j] != "default")
+            m.addLayer(Jax.Material.find(mats[j]));
+        
+        new Jax.Mesh({material:m}).render(SPEC_CONTEXT);
+      });
+    });
+  }
+});

data/spec/javascripts/shaders/fog_spec.js

@@ -0,0 +1,15 @@
+describe("Material segment 'fog'", function() {
+  var matr;
+  
+  beforeEach(function() {
+    matr = new Jax.Material();
+    spyOn(matr, 'prepareShader').andCallThrough();
+  });
+  
+  it("should compile successfully", function() {
+    matr.addLayer(new Jax.Material.Fog({}));
+    
+    new Jax.Mesh({material:matr}).render(SPEC_CONTEXT);
+    expect(matr.prepareShader).toHaveBeenCalled();
+  });
+});

data/spec/javascripts/shaders/lighting_spec.js

@@ -0,0 +1,15 @@
+describe("Material segment 'lighting'", function() {
+  var matr;
+  
+  beforeEach(function() {
+    matr = new Jax.Material();
+    spyOn(matr, 'prepareShader').andCallThrough();
+  });
+  
+  it("should compile successfully", function() {
+    matr.addLayer(new Jax.Material.Lighting());
+    
+    new Jax.Mesh({material:matr}).render(SPEC_CONTEXT);
+    expect(matr.prepareShader).toHaveBeenCalled();
+  });
+});

data/spec/javascripts/shaders/normal_map_spec.js

@@ -0,0 +1,15 @@
+describe("Material segment 'normal_map'", function() {
+  var matr;
+  
+  beforeEach(function() {
+    matr = new Jax.Material();
+    spyOn(matr, 'prepareShader').andCallThrough();
+  });
+  
+  it("should compile successfully", function() {
+    matr.addLayer(new Jax.Material.NormalMap(new Jax.Texture("/textures/normal_map.jpg")));
+    
+    new Jax.Mesh({material:matr}).render(SPEC_CONTEXT);
+    expect(matr.prepareShader).toHaveBeenCalled();
+  });
+});

data/spec/javascripts/shaders/paraboloid_spec.js

@@ -0,0 +1,33 @@
+describe("Material segment 'paraboloid'", function() {
+  var matr;
+  
+  beforeEach(function() {
+    matr = new Jax.Material.Paraboloid();
+    spyOn(matr, 'prepareShader').andCallThrough();
+  });
+  
+  it("should compile successfully", function() {
+    new Jax.Mesh({material:matr}).render(SPEC_CONTEXT);
+    expect(matr.prepareShader).toHaveBeenCalled();
+  });
+
+  it("should be rendered in both directions", function() {
+    var front = false, back = false;
+    var mesh = new Jax.Mesh.Quad({material:matr});
+    
+    var old_render = mesh.render;
+
+    mesh.render = function(context, options) {
+      if (options && options.direction && options.direction ==  1) front = true;
+      if (options && options.direction && options.direction == -1) back = true;
+      old_render.apply(this, arguments);
+    };
+    
+    SPEC_CONTEXT.world.addObject(new Jax.Model({mesh: mesh}));
+    SPEC_CONTEXT.world.addLightSource(new Jax.Scene.LightSource({type:Jax.POINT_LIGHT}));
+    SPEC_CONTEXT.world.render();
+    
+    expect(front).toBeTrue();
+    expect(back).toBeTrue();
+  });
+});

data/spec/javascripts/shaders/preprocessor_spec.js

@@ -0,0 +1,45 @@
+describe("Preprocessor", function() {
+  var matr;
+  
+  beforeEach(function() {
+    matr = new Jax.Material();
+  });
+  
+  it("should be able to determine shader type from within common code", function() {
+    Jax.shaders['test'] = new Jax.Shader({
+      common: "void <%=shader_type%>(void) { return; }",
+      vertex: "void main(void) { gl_Position = vec4(0,0,0,1); }",
+      fragment: "void main(void) { discard; }",
+      name: "test"
+    });
+    
+    expect(Jax.shaders['test'].getVertexSource(matr)).toMatch(/void vertex\(void\)/);
+    expect(Jax.shaders['test'].getFragmentSource(matr)).toMatch(/void fragment\(void\)/);
+  });
+  
+  describe("with multiple similar vardecs", function() {
+    Jax.shaders['test'] = new Jax.Shader({
+      vertex: "shared uniform mat4 ivMatrix, mvMatrix, pMatrix, vMatrix;\n" +
+              "uniform mat4 imvMatrix;\n" +
+              "void main(void) { gl_Position = pMatrix * imvMatrix * vec4(0,0,0,1); }",
+      fragment: "void main(void) { }",
+      name: "test"
+    });
+
+    var TestMaterial = Jax.Class.create(Jax.Material, {
+      initialize: function($super) { $super({shader: "test"}); },
+
+      setVariables: function(context, mesh, options, vars) {
+        vars.set('imvMatrix', context.getInverseModelViewMatrix());
+      }
+    });
+
+    beforeEach(function() {
+      matr.addLayer(new TestMaterial());
+    });
+
+    it("should should not fail", function() {
+      new Jax.Mesh({material:matr}).render(SPEC_CONTEXT);
+    });
+  });
+});

data/spec/javascripts/shaders/shadow_map_spec.js

@@ -0,0 +1,15 @@
+describe("Material segment 'shadow_map'", function() {
+  var matr;
+  
+  beforeEach(function() {
+    matr = new Jax.Material();
+    spyOn(matr, 'prepareShader').andCallThrough();
+  });
+  
+  it("should compile successfully", function() {
+    matr.addLayer(new Jax.Material.ShadowMap());
+    
+    new Jax.Mesh({material:matr}).render(SPEC_CONTEXT);
+    expect(matr.prepareShader).toHaveBeenCalled();
+  });
+});

data/spec/javascripts/shaders/texture_spec.js

@@ -0,0 +1,37 @@
+describe("Material segment 'texture'", function() {
+  var matr;
+  
+  beforeEach(function() {
+    matr = new Jax.Material();
+    spyOn(matr, 'prepareShader').andCallThrough();
+  });
+  
+  it("should not replace options if image is POT", function() {
+    matr = new Jax.Material({"ambient":{"red":1.0,"green":1.0,"blue":1.0,"alpha":1.0},
+      "diffuse":{"red":1.0,"green":1.0,"blue":1.0,"alpha":1.0},
+      "specular":{"red":1.0,"green":1.0,"blue":1.0,"alpha":1.0},
+      "shininess":30,
+      "layers":[
+        {"type":"Lighting"},
+        {"type":"Texture","path":"/textures/rock.png","flip_y":false,"scale_x":1.0,"scale_y":1.0,"generate_mipmap":true,"min_filter":"GL_NEAREST","mag_filter":"GL_NEAREST","mipmap_hint":"GL_DONT_CARE","format":"GL_RGBA","data_type":"GL_UNSIGNED_BYTE","wrap_s":"GL_REPEAT","wrap_t":"GL_REPEAT","premultiply_alpha":false,"colorspace_conversion":true},
+        {"type":"NormalMap","path":"/textures/rock_normal.png","flip_y":false,"scale_x":1.0,"scale_y":1.0,"generate_mipmap":true,"min_filter":"GL_NEAREST","mag_filter":"GL_NEAREST","mipmap_hint":"GL_DONT_CARE","format":"GL_RGBA","data_type":"GL_UNSIGNED_BYTE","wrap_s":"GL_REPEAT","wrap_t":"GL_REPEAT","premultiply_alpha":false,"colorspace_conversion":true}
+      ]
+    });
+    matr.layers[1].texture.image.width = matr.layers[1].texture.image.height = 256;
+
+    waitsFor(function() {
+      if (matr.layers[1].texture.loaded) {
+        expect(Jax.Util.enumName(matr.layers[1].texture.options.wrap_s)).toEqual("GL_REPEAT");
+        return true;
+      }
+      return false;
+    });
+  });
+  
+  it("should compile successfully", function() {
+    matr.addLayer(new Jax.Material.Texture(new Jax.Texture("/textures/rss.png")));
+    
+    new Jax.Mesh({material:matr}).render(SPEC_CONTEXT);
+    expect(matr.prepareShader).toHaveBeenCalled();
+  });
+});

data/spec/javascripts/suite/controller_select_spec.js.coffee

@@ -0,0 +1,24 @@
+#= require "jquery"
+#= require "jax/controller-select"
+
+describe "The select box in the dev suite runtime", ->
+  select = null
+  
+  beforeEach ->
+    Jax.routes.clear()
+    Jax.views.push 'welcome/index', -> 1
+    Jax.Controller.create "Welcome", index: -> 1
+    select = document.createElement "select"
+    _controller_select_fill select
+  
+  it "should contain the 'Welcome' controller", ->
+    expect(select.options[0].value).toEqual("welcome")
+
+  describe "clicked", ->
+    beforeEach ->
+      select.webgl_context = SPEC_CONTEXT
+      select.selectedIndex = 0
+      $(select).trigger("change");
+    
+    it "should redirect to the selected controller", ->
+      expect(SPEC_CONTEXT.current_controller.getControllerName()).toEqual("Welcome")