OLD | NEW |
(Empty) | |
| 1 // ArgGenerators contains argument generators for WebGL functions. |
| 2 // The argument generators are used for running random tests against the WebGL |
| 3 // functions. |
| 4 // |
| 5 // ArgGenerators is an object consisting of functionName : argGen -properties. |
| 6 // |
| 7 // functionName is a WebGL context function name and the argGen is an argument |
| 8 // generator object that encapsulates the requirements to run |
| 9 // randomly generated tests on the WebGL function. |
| 10 // |
| 11 // An argGen object has the following methods: |
| 12 // - setup -- set up state for testing the GL function, returns values |
| 13 // that need cleanup in teardown. Run once before entering a |
| 14 // test loop. |
| 15 // - teardown -- do cleanup on setup's return values after testing is complete |
| 16 // - generate -- generate a valid set of random arguments for the GL function |
| 17 // - returnValueCleanup -- do cleanup on value returned by the tested GL funct
ion |
| 18 // - cleanup -- do cleanup on generated arguments from generate |
| 19 // - checkArgValidity -- check if passed args are valid. Has a call signature |
| 20 // that matches generate's return value. Returns true |
| 21 // if args are valid, false if not. |
| 22 // |
| 23 // Example test loop that demonstrates how the function args and return |
| 24 // values flow together: |
| 25 // |
| 26 // var setupArgs = argGen.setup(); |
| 27 // for (var i=0; i<numberOfTests; i++) { |
| 28 // var generatedArgs = argGen.generate.apply(argGen, setupArgs); |
| 29 // var validArgs = argGen.checkArgValidity.apply(argGen, generatedArgs); |
| 30 // var rv = call the GL function with generatedArgs; |
| 31 // argGen.returnValueCleanup(rv); |
| 32 // argGen.cleanup.apply(argGen, generatedArgs); |
| 33 // } |
| 34 // argGen.teardown.apply(argGen, setupArgs); |
| 35 // |
| 36 ArgGenerators = { |
| 37 |
| 38 // GL functions in alphabetical order |
| 39 |
| 40 // D |
| 41 |
| 42 deleteBuffer : { |
| 43 generate : function() { return [GL.createBuffer()]; }, |
| 44 checkArgValidity : function(o) { |
| 45 GL.bindBuffer(GL.ARRAY_BUFFER, o); |
| 46 return GL.isBuffer(o); |
| 47 }, |
| 48 cleanup : function(o) { |
| 49 GL.bindBuffer(GL.ARRAY_BUFFER, null); |
| 50 try { GL.deleteBuffer(o); } catch(e) {} |
| 51 } |
| 52 }, |
| 53 deleteFramebuffer : { |
| 54 generate : function() { return [GL.createFramebuffer()]; }, |
| 55 checkArgValidity : function(o) { |
| 56 GL.bindFramebuffer(GL.FRAMEBUFFER, o); |
| 57 return GL.isFramebuffer(o); |
| 58 }, |
| 59 cleanup : function(o) { |
| 60 GL.bindFramebuffer(GL.FRAMEBUFFER, null); |
| 61 try { GL.deleteFramebuffer(o); } catch(e) {} |
| 62 } |
| 63 }, |
| 64 deleteProgram : { |
| 65 generate : function() { return [GL.createProgram()]; }, |
| 66 checkArgValidity : function(o) { return GL.isProgram(o); }, |
| 67 cleanup : function(o) { try { GL.deleteProgram(o); } catch(e) {} } |
| 68 }, |
| 69 deleteRenderbuffer : { |
| 70 generate : function() { return [GL.createRenderbuffer()]; }, |
| 71 checkArgValidity : function(o) { |
| 72 GL.bindRenderbuffer(GL.RENDERBUFFER, o); |
| 73 return GL.isRenderbuffer(o); |
| 74 }, |
| 75 cleanup : function(o) { |
| 76 GL.bindRenderbuffer(GL.RENDERBUFFER, null); |
| 77 try { GL.deleteRenderbuffer(o); } catch(e) {} |
| 78 } |
| 79 }, |
| 80 deleteShader : { |
| 81 generate : function() { return [GL.createShader(shaderType.random())]; }, |
| 82 checkArgValidity : function(o) { return GL.isShader(o); }, |
| 83 cleanup : function(o) { try { GL.deleteShader(o); } catch(e) {} } |
| 84 }, |
| 85 deleteTexture : { |
| 86 generate : function() { return [GL.createTexture()]; }, |
| 87 checkArgValidity : function(o) { |
| 88 GL.bindTexture(GL.TEXTURE_2D, o); |
| 89 return GL.isTexture(o); |
| 90 }, |
| 91 cleanup : function(o) { |
| 92 GL.bindTexture(GL.TEXTURE_2D, null); |
| 93 try { GL.deleteTexture(o); } catch(e) {} |
| 94 } |
| 95 }, |
| 96 depthFunc : { |
| 97 generate : function() { return [depthFuncFunc.random()]; }, |
| 98 checkArgValidity : function(f) { return depthFuncFunc.has(f); }, |
| 99 teardown : function() { GL.depthFunc(GL.LESS); } |
| 100 }, |
| 101 depthMask : { |
| 102 generate : function() { return [randomBool()]; }, |
| 103 teardown : function() { GL.depthFunc(GL.TRUE); } |
| 104 }, |
| 105 depthRange : { |
| 106 generate : function() { return [Math.random(), Math.random()]; }, |
| 107 teardown : function() { GL.depthRange(0, 1); } |
| 108 }, |
| 109 detachShader : { |
| 110 generate : function() { |
| 111 var p = GL.createProgram(); |
| 112 var sh = GL.createShader(shaderType.random()); |
| 113 GL.attachShader(p, sh); |
| 114 return [p, sh]; |
| 115 }, |
| 116 checkArgValidity : function(p, sh) { |
| 117 return GL.isProgram(p) && GL.isShader(sh) && GL.getAttachedShaders(p).has(
sh); |
| 118 }, |
| 119 cleanup : function(p, sh) { |
| 120 try {GL.deleteProgram(p);} catch(e) {} |
| 121 try {GL.deleteShader(sh);} catch(e) {} |
| 122 } |
| 123 }, |
| 124 disable : { |
| 125 generate : function() { return [enableCap.random()]; }, |
| 126 checkArgValidity : function(c) { return enableCap.has(c); }, |
| 127 cleanup : function(c) { if (c == GL.DITHER) GL.enable(c); } |
| 128 }, |
| 129 disableVertexAttribArray : { |
| 130 generate : function() { return [randomVertexAttribute()]; }, |
| 131 checkArgValidity : function(v) { return isVertexAttribute(v); } |
| 132 }, |
| 133 drawArrays : {}, // FIXME |
| 134 drawElements : {}, // FIXME |
| 135 |
| 136 // E |
| 137 |
| 138 enable : { |
| 139 generate : function() { return [enableCap.random()]; }, |
| 140 checkArgValidity : function(c) { return enableCap.has(c); }, |
| 141 cleanup : function(c) { if (c != GL.DITHER) GL.disable(c); } |
| 142 }, |
| 143 enableVertexAttribArray : { |
| 144 generate : function() { return [randomVertexAttribute()]; }, |
| 145 checkArgValidity : function(v) { return isVertexAttribute(castToInt(v)); }, |
| 146 cleanup : function(v) { GL.disableVertexAttribArray(v); } |
| 147 }, |
| 148 |
| 149 // F |
| 150 |
| 151 finish : { |
| 152 generate : function() { return []; } |
| 153 }, |
| 154 flush : { |
| 155 generate : function() { return []; } |
| 156 }, |
| 157 framebufferRenderbuffer : {}, // FIXME |
| 158 framebufferTexture2D : {}, // FIXME |
| 159 frontFace : { |
| 160 generate : function() { return [frontFaceMode.random()]; }, |
| 161 checkArgValidity : function(c) { return frontFaceMode.has(c); }, |
| 162 cleanup : function(c) { GL.frontFace(GL.CCW); } |
| 163 }, |
| 164 |
| 165 // G-1 |
| 166 |
| 167 generateMipmap : { |
| 168 setup : function() { |
| 169 var tex = GL.createTexture(); |
| 170 var tex2 = GL.createTexture(); |
| 171 GL.bindTexture(GL.TEXTURE_2D, tex); |
| 172 GL.bindTexture(GL.TEXTURE_CUBE_MAP, tex2); |
| 173 var pix = new Uint8Array(16*16*4); |
| 174 GL.texImage2D(GL.TEXTURE_2D, 0, GL.RGBA, 16, 16, 0, GL.RGBA, GL.UNSIGNED_B
YTE, pix); |
| 175 GL.texImage2D(GL.TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL.RGBA, 16, 16, 0, GL.RG
BA, GL.UNSIGNED_BYTE, pix); |
| 176 GL.texImage2D(GL.TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL.RGBA, 16, 16, 0, GL.RG
BA, GL.UNSIGNED_BYTE, pix); |
| 177 GL.texImage2D(GL.TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL.RGBA, 16, 16, 0, GL.RG
BA, GL.UNSIGNED_BYTE, pix); |
| 178 GL.texImage2D(GL.TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL.RGBA, 16, 16, 0, GL.RG
BA, GL.UNSIGNED_BYTE, pix); |
| 179 GL.texImage2D(GL.TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL.RGBA, 16, 16, 0, GL.RG
BA, GL.UNSIGNED_BYTE, pix); |
| 180 GL.texImage2D(GL.TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL.RGBA, 16, 16, 0, GL.RG
BA, GL.UNSIGNED_BYTE, pix); |
| 181 }, |
| 182 generate : function() { return [bindTextureTarget.random()]; }, |
| 183 checkArgValidity : function(t) { return bindTextureTarget.has(t); }, |
| 184 teardown : function(tex, tex2) { |
| 185 GL.bindTexture(GL.TEXTURE_2D, null); |
| 186 GL.bindTexture(GL.TEXTURE_CUBE_MAP, null); |
| 187 GL.deleteTexture(tex); |
| 188 GL.deleteTexture(tex2); |
| 189 } |
| 190 }, |
| 191 getActiveAttrib : { |
| 192 /* FIXME the queried attrib needs to be an active one |
| 193 generate : function() { |
| 194 var program = GL.createProgram(); |
| 195 return [program, randomVertexAttribute()]; |
| 196 }, |
| 197 checkArgValidity : function(program, index) { |
| 198 return GL.isProgram(program) && isVertexAttribute(index); |
| 199 }, |
| 200 cleanup : function(program, index) { |
| 201 GL.deleteProgram(program); |
| 202 } |
| 203 */ |
| 204 }, |
| 205 getActiveUniform : {}, // FIXME |
| 206 getAttachedShaders : { |
| 207 setup : function() { |
| 208 var program = GL.createProgram(); |
| 209 var s1 = GL.createShader(GL.VERTEX_SHADER); |
| 210 var s2 = GL.createShader(GL.FRAGMENT_SHADER); |
| 211 GL.attachShader(program, s1); |
| 212 GL.attachShader(program, s2); |
| 213 return [program, s1, s2]; |
| 214 }, |
| 215 generate : function(program, s1, s2) { |
| 216 return [program] |
| 217 }, |
| 218 checkArgValidity : function(program) { |
| 219 return GL.isProgram(program); |
| 220 }, |
| 221 teardown : function(program, s1, s2) { |
| 222 GL.deleteProgram(program); |
| 223 GL.deleteShader(s1); |
| 224 GL.deleteShader(s2); |
| 225 } |
| 226 } |
| 227 |
| 228 }; |
| 229 |
OLD | NEW |