diff options
Diffstat (limited to '')
28 files changed, 3786 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-A.js b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-A.js new file mode 100644 index 0000000000..c3e301ce14 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-A.js @@ -0,0 +1,69 @@ +/* +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +*/ + +// ArgGenerators contains argument generators for WebGL functions. +// The argument generators are used for running random tests against the WebGL +// functions. +// +// ArgGenerators is an object consisting of functionName : argGen -properties. +// +// functionName is a WebGL context function name and the argGen is an argument +// generator object that encapsulates the requirements to run +// randomly generated tests on the WebGL function. +// +// An argGen object has the following methods: +// - setup -- set up state for testing the GL function, returns values +// that need cleanup in teardown. Run once before entering a +// test loop. +// - teardown -- do cleanup on setup's return values after testing is complete +// - generate -- generate a valid set of random arguments for the GL function +// - returnValueCleanup -- do cleanup on value returned by the tested GL function +// - cleanup -- do cleanup on generated arguments from generate +// - checkArgValidity -- check if passed args are valid. Has a call signature +// that matches generate's return value. Returns true +// if args are valid, false if not. +// +// Example test loop that demonstrates how the function args and return +// values flow together: +// +// var setupArgs = argGen.setup(); +// for (var i=0; i<numberOfTests; i++) { +// var generatedArgs = argGen.generate.apply(argGen, setupArgs); +// var validArgs = argGen.checkArgValidity.apply(argGen, generatedArgs); +// var rv = call the GL function with generatedArgs; +// argGen.returnValueCleanup(rv); +// argGen.cleanup.apply(argGen, generatedArgs); +// } +// argGen.teardown.apply(argGen, setupArgs); +// +ArgGenerators = { + +// GL functions in alphabetical order + +// A + + activeTexture : { + generate : function() { return [textureUnit.random()]; }, + checkArgValidity : function(t) { return textureUnit.has(t); }, + teardown : function() { GL.activeTexture(GL.TEXTURE0); } + }, + attachShader : { + generate : function() { + var p = GL.createProgram(); + var sh = GL.createShader(shaderType.random()); + return [p, sh]; + }, + checkArgValidity : function(p, sh) { + return GL.isProgram(p) && GL.isShader(sh) && !GL.getAttachedShaders(p).has(sh); + }, + cleanup : function(p, sh) { + try {GL.detachShader(p,sh);} catch(e) {} + try {GL.deleteProgram(p);} catch(e) {} + try {GL.deleteShader(sh);} catch(e) {} + } + } + +}; diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-B1.js b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-B1.js new file mode 100644 index 0000000000..04f394be02 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-B1.js @@ -0,0 +1,61 @@ +/* +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +*/ + +// ArgGenerators contains argument generators for WebGL functions. +// The argument generators are used for running random tests against the WebGL +// functions. +// +// ArgGenerators is an object consisting of functionName : argGen -properties. +// +// functionName is a WebGL context function name and the argGen is an argument +// generator object that encapsulates the requirements to run +// randomly generated tests on the WebGL function. +// +// An argGen object has the following methods: +// - setup -- set up state for testing the GL function, returns values +// that need cleanup in teardown. Run once before entering a +// test loop. +// - teardown -- do cleanup on setup's return values after testing is complete +// - generate -- generate a valid set of random arguments for the GL function +// - returnValueCleanup -- do cleanup on value returned by the tested GL function +// - cleanup -- do cleanup on generated arguments from generate +// - checkArgValidity -- check if passed args are valid. Has a call signature +// that matches generate's return value. Returns true +// if args are valid, false if not. +// +// Example test loop that demonstrates how the function args and return +// values flow together: +// +// var setupArgs = argGen.setup(); +// for (var i=0; i<numberOfTests; i++) { +// var generatedArgs = argGen.generate.apply(argGen, setupArgs); +// var validArgs = argGen.checkArgValidity.apply(argGen, generatedArgs); +// var rv = call the GL function with generatedArgs; +// argGen.returnValueCleanup(rv); +// argGen.cleanup.apply(argGen, generatedArgs); +// } +// argGen.teardown.apply(argGen, setupArgs); +// +ArgGenerators = { + +// GL functions in alphabetical order + +// B-1 + + bindAttribLocation : { + generate : function() { + var program = GL.createProgram(); + return [program, randomVertexAttribute(), randomName()]; + }, + checkArgValidity : function(program, index, name) { + return GL.isProgram(program) && isVertexAttribute(index) && isValidName(name); + }, + cleanup : function(program, index, name) { + try { GL.deleteProgram(program); } catch(e) {} + } + } + +}; diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-B2.js b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-B2.js new file mode 100644 index 0000000000..f366c3d8f1 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-B2.js @@ -0,0 +1,154 @@ +/* +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +*/ + +// ArgGenerators contains argument generators for WebGL functions. +// The argument generators are used for running random tests against the WebGL +// functions. +// +// ArgGenerators is an object consisting of functionName : argGen -properties. +// +// functionName is a WebGL context function name and the argGen is an argument +// generator object that encapsulates the requirements to run +// randomly generated tests on the WebGL function. +// +// An argGen object has the following methods: +// - setup -- set up state for testing the GL function, returns values +// that need cleanup in teardown. Run once before entering a +// test loop. +// - teardown -- do cleanup on setup's return values after testing is complete +// - generate -- generate a valid set of random arguments for the GL function +// - returnValueCleanup -- do cleanup on value returned by the tested GL function +// - cleanup -- do cleanup on generated arguments from generate +// - checkArgValidity -- check if passed args are valid. Has a call signature +// that matches generate's return value. Returns true +// if args are valid, false if not. +// +// Example test loop that demonstrates how the function args and return +// values flow together: +// +// var setupArgs = argGen.setup(); +// for (var i=0; i<numberOfTests; i++) { +// var generatedArgs = argGen.generate.apply(argGen, setupArgs); +// var validArgs = argGen.checkArgValidity.apply(argGen, generatedArgs); +// var rv = call the GL function with generatedArgs; +// argGen.returnValueCleanup(rv); +// argGen.cleanup.apply(argGen, generatedArgs); +// } +// argGen.teardown.apply(argGen, setupArgs); +// +ArgGenerators = { + +// GL functions in alphabetical order + +// B-2 + + bindBuffer : { + generate : function(buf) { + return [bufferTarget.random(), GL.createBuffer()]; + }, + checkArgValidity : function(target, buf) { + if (!bufferTarget.has(target)) + return false; + GL.bindBuffer(target, buf); + return GL.isBuffer(buf); + }, + cleanup : function(t, buf, m) { + GL.deleteBuffer(buf); + } + }, + bindFramebuffer : { + generate : function() { + return [GL.FRAMEBUFFER, Math.random() > 0.5 ? null : GL.createFramebuffer()]; + }, + checkArgValidity : function(target, fbo) { + if (target != GL.FRAMEBUFFER) + return false; + if (fbo != null) + GL.bindFramebuffer(target, fbo); + return (fbo == null || GL.isFramebuffer(fbo)); + }, + cleanup : function(target, fbo) { + GL.bindFramebuffer(target, null); + if (fbo) + GL.deleteFramebuffer(fbo); + } + }, + bindRenderbuffer : { + generate : function() { + return [GL.RENDERBUFFER, Math.random() > 0.5 ? null : GL.createRenderbuffer()]; + }, + checkArgValidity : function(target, rbo) { + if (target != GL.RENDERBUFFER) + return false; + if (rbo != null) + GL.bindRenderbuffer(target, rbo); + return (rbo == null || GL.isRenderbuffer(rbo)); + }, + cleanup : function(target, rbo) { + GL.bindRenderbuffer(target, null); + if (rbo) + GL.deleteRenderbuffer(rbo); + } + }, + bindTexture : { + generate : function() { + return [bindTextureTarget.random(), Math.random() > 0.5 ? null : GL.createTexture()]; + }, + checkArgValidity : function(target, o) { + if (!bindTextureTarget.has(target)) + return false; + if (o != null) + GL.bindTexture(target, o); + return (o == null || GL.isTexture(o)); + }, + cleanup : function(target, o) { + GL.bindTexture(target, null); + if (o) + GL.deleteTexture(o); + } + }, + blendColor : { + generate : function() { return randomColor(); }, + teardown : function() { GL.blendColor(0,0,0,0); } + }, + blendEquation : { + generate : function() { return [blendEquationMode.random()]; }, + checkArgValidity : function(o) { return blendEquationMode.has(o); }, + teardown : function() { GL.blendEquation(GL.FUNC_ADD); } + }, + blendEquationSeparate : { + generate : function() { + return [blendEquationMode.random(), blendEquationMode.random()]; + }, + checkArgValidity : function(o,p) { + return blendEquationMode.has(o) && blendEquationMode.has(p); + }, + teardown : function() { GL.blendEquationSeparate(GL.FUNC_ADD, GL.FUNC_ADD); } + }, + blendFunc : { + generate : function() { + return [blendFuncSfactor.random(), blendFuncDfactor.random()]; + }, + checkArgValidity : function(s,d) { + return blendFuncSfactor.has(s) && blendFuncDfactor.has(d); + }, + teardown : function() { GL.blendFunc(GL.ONE, GL.ZERO); } + }, + blendFuncSeparate : { + generate : function() { + return [blendFuncSfactor.random(), blendFuncDfactor.random(), + blendFuncSfactor.random(), blendFuncDfactor.random()]; + }, + checkArgValidity : function(s,d,as,ad) { + return blendFuncSfactor.has(s) && blendFuncDfactor.has(d) && + blendFuncSfactor.has(as) && blendFuncDfactor.has(ad) ; + }, + teardown : function() { + GL.blendFuncSeparate(GL.ONE, GL.ZERO, GL.ONE, GL.ZERO); + } + } + +}; diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-B3.js b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-B3.js new file mode 100644 index 0000000000..2a4796d914 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-B3.js @@ -0,0 +1,68 @@ +/* +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +*/ + +// ArgGenerators contains argument generators for WebGL functions. +// The argument generators are used for running random tests against the WebGL +// functions. +// +// ArgGenerators is an object consisting of functionName : argGen -properties. +// +// functionName is a WebGL context function name and the argGen is an argument +// generator object that encapsulates the requirements to run +// randomly generated tests on the WebGL function. +// +// An argGen object has the following methods: +// - setup -- set up state for testing the GL function, returns values +// that need cleanup in teardown. Run once before entering a +// test loop. +// - teardown -- do cleanup on setup's return values after testing is complete +// - generate -- generate a valid set of random arguments for the GL function +// - returnValueCleanup -- do cleanup on value returned by the tested GL function +// - cleanup -- do cleanup on generated arguments from generate +// - checkArgValidity -- check if passed args are valid. Has a call signature +// that matches generate's return value. Returns true +// if args are valid, false if not. +// +// Example test loop that demonstrates how the function args and return +// values flow together: +// +// var setupArgs = argGen.setup(); +// for (var i=0; i<numberOfTests; i++) { +// var generatedArgs = argGen.generate.apply(argGen, setupArgs); +// var validArgs = argGen.checkArgValidity.apply(argGen, generatedArgs); +// var rv = call the GL function with generatedArgs; +// argGen.returnValueCleanup(rv); +// argGen.cleanup.apply(argGen, generatedArgs); +// } +// argGen.teardown.apply(argGen, setupArgs); +// +ArgGenerators = { + +// GL functions in alphabetical order + +// B-3 + + bufferData : { + setup : function() { + var buf = GL.createBuffer(); + var ebuf = GL.createBuffer(); + GL.bindBuffer(GL.ARRAY_BUFFER, buf); + GL.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, ebuf); + return [buf, ebuf]; + }, + generate : function(buf, ebuf) { + return [bufferTarget.random(), randomBufferData(), bufferMode.random()]; + }, + checkArgValidity : function(target, bufData, mode) { + return bufferTarget.has(target) && isBufferData(bufData) && bufferMode.has(mode); + }, + teardown : function(buf, ebuf) { + GL.deleteBuffer(buf); + GL.deleteBuffer(ebuf); + }, + } + +}; diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-B4.js b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-B4.js new file mode 100644 index 0000000000..4c1ca7d8b9 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-B4.js @@ -0,0 +1,71 @@ +/* +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +*/ + +// ArgGenerators contains argument generators for WebGL functions. +// The argument generators are used for running random tests against the WebGL +// functions. +// +// ArgGenerators is an object consisting of functionName : argGen -properties. +// +// functionName is a WebGL context function name and the argGen is an argument +// generator object that encapsulates the requirements to run +// randomly generated tests on the WebGL function. +// +// An argGen object has the following methods: +// - setup -- set up state for testing the GL function, returns values +// that need cleanup in teardown. Run once before entering a +// test loop. +// - teardown -- do cleanup on setup's return values after testing is complete +// - generate -- generate a valid set of random arguments for the GL function +// - returnValueCleanup -- do cleanup on value returned by the tested GL function +// - cleanup -- do cleanup on generated arguments from generate +// - checkArgValidity -- check if passed args are valid. Has a call signature +// that matches generate's return value. Returns true +// if args are valid, false if not. +// +// Example test loop that demonstrates how the function args and return +// values flow together: +// +// var setupArgs = argGen.setup(); +// for (var i=0; i<numberOfTests; i++) { +// var generatedArgs = argGen.generate.apply(argGen, setupArgs); +// var validArgs = argGen.checkArgValidity.apply(argGen, generatedArgs); +// var rv = call the GL function with generatedArgs; +// argGen.returnValueCleanup(rv); +// argGen.cleanup.apply(argGen, generatedArgs); +// } +// argGen.teardown.apply(argGen, setupArgs); +// +ArgGenerators = { + +// GL functions in alphabetical order + +// B-4 + + bufferSubData : { + setup : function() { + var buf = GL.createBuffer(); + var ebuf = GL.createBuffer(); + GL.bindBuffer(GL.ARRAY_BUFFER, buf); + GL.bufferData(GL.ARRAY_BUFFER, 256, GL.STATIC_DRAW); + GL.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, ebuf); + GL.bufferData(GL.ELEMENT_ARRAY_BUFFER, 256, GL.STATIC_DRAW); + return [buf, ebuf]; + }, + generate : function(buf, ebuf) { + var d = randomBufferSubData(256); + return [bufferTarget.random(), d.offset, d.data]; + }, + checkArgValidity : function(target, offset, data) { + return bufferTarget.has(target) && offset >= 0 && data.byteLength >= 0 && offset + data.byteLength <= 256; + }, + teardown : function(buf, ebuf) { + GL.deleteBuffer(buf); + GL.deleteBuffer(ebuf); + }, + } + +}; diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-C.js b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-C.js new file mode 100644 index 0000000000..fbe1c2a5c5 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-C.js @@ -0,0 +1,119 @@ +/* +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +*/ + +// ArgGenerators contains argument generators for WebGL functions. +// The argument generators are used for running random tests against the WebGL +// functions. +// +// ArgGenerators is an object consisting of functionName : argGen -properties. +// +// functionName is a WebGL context function name and the argGen is an argument +// generator object that encapsulates the requirements to run +// randomly generated tests on the WebGL function. +// +// An argGen object has the following methods: +// - setup -- set up state for testing the GL function, returns values +// that need cleanup in teardown. Run once before entering a +// test loop. +// - teardown -- do cleanup on setup's return values after testing is complete +// - generate -- generate a valid set of random arguments for the GL function +// - returnValueCleanup -- do cleanup on value returned by the tested GL function +// - cleanup -- do cleanup on generated arguments from generate +// - checkArgValidity -- check if passed args are valid. Has a call signature +// that matches generate's return value. Returns true +// if args are valid, false if not. +// +// Example test loop that demonstrates how the function args and return +// values flow together: +// +// var setupArgs = argGen.setup(); +// for (var i=0; i<numberOfTests; i++) { +// var generatedArgs = argGen.generate.apply(argGen, setupArgs); +// var validArgs = argGen.checkArgValidity.apply(argGen, generatedArgs); +// var rv = call the GL function with generatedArgs; +// argGen.returnValueCleanup(rv); +// argGen.cleanup.apply(argGen, generatedArgs); +// } +// argGen.teardown.apply(argGen, setupArgs); +// +ArgGenerators = { + +// GL functions in alphabetical order + +// C + + checkFramebufferStatus : { + generate : function() { + return [Math.random() > 0.5 ? null : GL.createFramebuffer()]; + }, + checkArgValidity : function(fbo) { + if (fbo != null) + GL.bindFramebuffer(GL.FRAMEBUFFER, fbo); + return fbo == null || GL.isFramebuffer(fbo); + }, + cleanup : function(fbo){ + GL.bindFramebuffer(GL.FRAMEBUFFER, null); + if (fbo != null) + try{ GL.deleteFramebuffer(fbo); } catch(e) {} + } + }, + clear : { + generate : function() { return [clearMask.random()]; }, + checkArgValidity : function(mask) { return clearMask.has(mask); } + }, + clearColor : { + generate : function() { return randomColor(); }, + teardown : function() { GL.clearColor(0,0,0,0); } + }, + clearDepth : { + generate : function() { return [Math.random()]; }, + teardown : function() { GL.clearDepth(1); } + }, + clearStencil : { + generate : function() { return [randomStencil()]; }, + teardown : function() { GL.clearStencil(0); } + }, + colorMask : { + generate : function() { + return [randomBool(), randomBool(), randomBool(), randomBool()]; + }, + teardown : function() { GL.colorMask(true, true, true, true); } + }, + compileShader : {}, // FIXME + copyTexImage2D : {}, // FIXME + copyTexSubImage2D : {}, // FIXME + createBuffer : { + generate : function() { return []; }, + returnValueCleanup : function(o) { GL.deleteBuffer(o); } + }, + createFramebuffer : { + generate : function() { return []; }, + returnValueCleanup : function(o) { GL.deleteFramebuffer(o); } + }, + createProgram : { + generate : function() { return []; }, + returnValueCleanup : function(o) { GL.deleteProgram(o); } + }, + createRenderbuffer : { + generate : function() { return []; }, + returnValueCleanup : function(o) { GL.deleteRenderbuffer(o); } + }, + createShader : { + generate : function() { return [shaderType.random()]; }, + checkArgValidity : function(t) { return shaderType.has(t); }, + returnValueCleanup : function(o) { GL.deleteShader(o); } + }, + createTexture : { + generate : function() { return []; }, + returnValueCleanup : function(o) { GL.deleteTexture(o); } + }, + cullFace : { + generate : function() { return [cullFace.random()]; }, + checkArgValidity : function(f) { return cullFace.has(f); }, + teardown : function() { GL.cullFace(GL.BACK); } + } + +}; diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-D_G.js b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-D_G.js new file mode 100644 index 0000000000..00e602002f --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-D_G.js @@ -0,0 +1,235 @@ +/* +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +*/ + +// ArgGenerators contains argument generators for WebGL functions. +// The argument generators are used for running random tests against the WebGL +// functions. +// +// ArgGenerators is an object consisting of functionName : argGen -properties. +// +// functionName is a WebGL context function name and the argGen is an argument +// generator object that encapsulates the requirements to run +// randomly generated tests on the WebGL function. +// +// An argGen object has the following methods: +// - setup -- set up state for testing the GL function, returns values +// that need cleanup in teardown. Run once before entering a +// test loop. +// - teardown -- do cleanup on setup's return values after testing is complete +// - generate -- generate a valid set of random arguments for the GL function +// - returnValueCleanup -- do cleanup on value returned by the tested GL function +// - cleanup -- do cleanup on generated arguments from generate +// - checkArgValidity -- check if passed args are valid. Has a call signature +// that matches generate's return value. Returns true +// if args are valid, false if not. +// +// Example test loop that demonstrates how the function args and return +// values flow together: +// +// var setupArgs = argGen.setup(); +// for (var i=0; i<numberOfTests; i++) { +// var generatedArgs = argGen.generate.apply(argGen, setupArgs); +// var validArgs = argGen.checkArgValidity.apply(argGen, generatedArgs); +// var rv = call the GL function with generatedArgs; +// argGen.returnValueCleanup(rv); +// argGen.cleanup.apply(argGen, generatedArgs); +// } +// argGen.teardown.apply(argGen, setupArgs); +// +ArgGenerators = { + +// GL functions in alphabetical order + +// D + + deleteBuffer : { + generate : function() { return [GL.createBuffer()]; }, + checkArgValidity : function(o) { + GL.bindBuffer(GL.ARRAY_BUFFER, o); + return GL.isBuffer(o); + }, + cleanup : function(o) { + GL.bindBuffer(GL.ARRAY_BUFFER, null); + try { GL.deleteBuffer(o); } catch(e) {} + } + }, + deleteFramebuffer : { + generate : function() { return [GL.createFramebuffer()]; }, + checkArgValidity : function(o) { + GL.bindFramebuffer(GL.FRAMEBUFFER, o); + return GL.isFramebuffer(o); + }, + cleanup : function(o) { + GL.bindFramebuffer(GL.FRAMEBUFFER, null); + try { GL.deleteFramebuffer(o); } catch(e) {} + } + }, + deleteProgram : { + generate : function() { return [GL.createProgram()]; }, + checkArgValidity : function(o) { return GL.isProgram(o); }, + cleanup : function(o) { try { GL.deleteProgram(o); } catch(e) {} } + }, + deleteRenderbuffer : { + generate : function() { return [GL.createRenderbuffer()]; }, + checkArgValidity : function(o) { + GL.bindRenderbuffer(GL.RENDERBUFFER, o); + return GL.isRenderbuffer(o); + }, + cleanup : function(o) { + GL.bindRenderbuffer(GL.RENDERBUFFER, null); + try { GL.deleteRenderbuffer(o); } catch(e) {} + } + }, + deleteShader : { + generate : function() { return [GL.createShader(shaderType.random())]; }, + checkArgValidity : function(o) { return GL.isShader(o); }, + cleanup : function(o) { try { GL.deleteShader(o); } catch(e) {} } + }, + deleteTexture : { + generate : function() { return [GL.createTexture()]; }, + checkArgValidity : function(o) { + GL.bindTexture(GL.TEXTURE_2D, o); + return GL.isTexture(o); + }, + cleanup : function(o) { + GL.bindTexture(GL.TEXTURE_2D, null); + try { GL.deleteTexture(o); } catch(e) {} + } + }, + depthFunc : { + generate : function() { return [depthFuncFunc.random()]; }, + checkArgValidity : function(f) { return depthFuncFunc.has(f); }, + teardown : function() { GL.depthFunc(GL.LESS); } + }, + depthMask : { + generate : function() { return [randomBool()]; }, + teardown : function() { GL.depthFunc(GL.TRUE); } + }, + depthRange : { + generate : function() { return [Math.random(), Math.random()]; }, + teardown : function() { GL.depthRange(0, 1); } + }, + detachShader : { + generate : function() { + var p = GL.createProgram(); + var sh = GL.createShader(shaderType.random()); + GL.attachShader(p, sh); + return [p, sh]; + }, + checkArgValidity : function(p, sh) { + return GL.isProgram(p) && GL.isShader(sh) && GL.getAttachedShaders(p).has(sh); + }, + cleanup : function(p, sh) { + try {GL.deleteProgram(p);} catch(e) {} + try {GL.deleteShader(sh);} catch(e) {} + } + }, + disable : { + generate : function() { return [enableCap.random()]; }, + checkArgValidity : function(c) { return enableCap.has(c); }, + cleanup : function(c) { if (c == GL.DITHER) GL.enable(c); } + }, + disableVertexAttribArray : { + generate : function() { return [randomVertexAttribute()]; }, + checkArgValidity : function(v) { return isVertexAttribute(v); } + }, + drawArrays : {}, // FIXME + drawElements : {}, // FIXME + +// E + + enable : { + generate : function() { return [enableCap.random()]; }, + checkArgValidity : function(c) { return enableCap.has(c); }, + cleanup : function(c) { if (c != GL.DITHER) GL.disable(c); } + }, + enableVertexAttribArray : { + generate : function() { return [randomVertexAttribute()]; }, + checkArgValidity : function(v) { return isVertexAttribute(castToInt(v)); }, + cleanup : function(v) { GL.disableVertexAttribArray(v); } + }, + +// F + + finish : { + generate : function() { return []; } + }, + flush : { + generate : function() { return []; } + }, + framebufferRenderbuffer : {}, // FIXME + framebufferTexture2D : {}, // FIXME + frontFace : { + generate : function() { return [frontFaceMode.random()]; }, + checkArgValidity : function(c) { return frontFaceMode.has(c); }, + cleanup : function(c) { GL.frontFace(GL.CCW); } + }, + +// G-1 + + generateMipmap : { + setup : function() { + var tex = GL.createTexture(); + var tex2 = GL.createTexture(); + GL.bindTexture(GL.TEXTURE_2D, tex); + GL.bindTexture(GL.TEXTURE_CUBE_MAP, tex2); + var pix = new Uint8Array(16*16*4); + GL.texImage2D(GL.TEXTURE_2D, 0, GL.RGBA, 16, 16, 0, GL.RGBA, GL.UNSIGNED_BYTE, pix); + GL.texImage2D(GL.TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL.RGBA, 16, 16, 0, GL.RGBA, GL.UNSIGNED_BYTE, pix); + GL.texImage2D(GL.TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL.RGBA, 16, 16, 0, GL.RGBA, GL.UNSIGNED_BYTE, pix); + GL.texImage2D(GL.TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL.RGBA, 16, 16, 0, GL.RGBA, GL.UNSIGNED_BYTE, pix); + GL.texImage2D(GL.TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL.RGBA, 16, 16, 0, GL.RGBA, GL.UNSIGNED_BYTE, pix); + GL.texImage2D(GL.TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL.RGBA, 16, 16, 0, GL.RGBA, GL.UNSIGNED_BYTE, pix); + GL.texImage2D(GL.TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL.RGBA, 16, 16, 0, GL.RGBA, GL.UNSIGNED_BYTE, pix); + }, + generate : function() { return [bindTextureTarget.random()]; }, + checkArgValidity : function(t) { return bindTextureTarget.has(t); }, + teardown : function(tex, tex2) { + GL.bindTexture(GL.TEXTURE_2D, null); + GL.bindTexture(GL.TEXTURE_CUBE_MAP, null); + GL.deleteTexture(tex); + GL.deleteTexture(tex2); + } + }, + getActiveAttrib : { + /* FIXME the queried attrib needs to be an active one + generate : function() { + var program = GL.createProgram(); + return [program, randomVertexAttribute()]; + }, + checkArgValidity : function(program, index) { + return GL.isProgram(program) && isVertexAttribute(index); + }, + cleanup : function(program, index) { + GL.deleteProgram(program); + } + */ + }, + getActiveUniform : {}, // FIXME + getAttachedShaders : { + setup : function() { + var program = GL.createProgram(); + var s1 = GL.createShader(GL.VERTEX_SHADER); + var s2 = GL.createShader(GL.FRAGMENT_SHADER); + GL.attachShader(program, s1); + GL.attachShader(program, s2); + return [program, s1, s2]; + }, + generate : function(program, s1, s2) { + return [program] + }, + checkArgValidity : function(program) { + return GL.isProgram(program); + }, + teardown : function(program, s1, s2) { + GL.deleteProgram(program); + GL.deleteShader(s1); + GL.deleteShader(s2); + } + } + +}; + diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-G_I.js b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-G_I.js new file mode 100644 index 0000000000..6aa2474241 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-G_I.js @@ -0,0 +1,124 @@ +/* +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +*/ + +// ArgGenerators contains argument generators for WebGL functions. +// The argument generators are used for running random tests against the WebGL +// functions. +// +// ArgGenerators is an object consisting of functionName : argGen -properties. +// +// functionName is a WebGL context function name and the argGen is an argument +// generator object that encapsulates the requirements to run +// randomly generated tests on the WebGL function. +// +// An argGen object has the following methods: +// - setup -- set up state for testing the GL function, returns values +// that need cleanup in teardown. Run once before entering a +// test loop. +// - teardown -- do cleanup on setup's return values after testing is complete +// - generate -- generate a valid set of random arguments for the GL function +// - returnValueCleanup -- do cleanup on value returned by the tested GL function +// - cleanup -- do cleanup on generated arguments from generate +// - checkArgValidity -- check if passed args are valid. Has a call signature +// that matches generate's return value. Returns true +// if args are valid, false if not. +// +// Example test loop that demonstrates how the function args and return +// values flow together: +// +// var setupArgs = argGen.setup(); +// for (var i=0; i<numberOfTests; i++) { +// var generatedArgs = argGen.generate.apply(argGen, setupArgs); +// var validArgs = argGen.checkArgValidity.apply(argGen, generatedArgs); +// var rv = call the GL function with generatedArgs; +// argGen.returnValueCleanup(rv); +// argGen.cleanup.apply(argGen, generatedArgs); +// } +// argGen.teardown.apply(argGen, setupArgs); +// +ArgGenerators = { + +// GL functions in alphabetical order + +// G-2 + + getAttribLocation : { + generate : function() { + var program = GL.createProgram(); + var name = randomName(); + GL.bindAttribLocation(program, randomVertexAttribute(), name); + return [program, name]; + }, + checkArgValidity : function(program, name) { + return GL.isProgram(program) && isValidName(name); + }, + cleanup : function(program, name) { + try { GL.deleteProgram(program); } catch(e) {} + } + },/* + getParameter : { + generate : function() { return [getParameterPname.random()]; }, + checkArgValidity : function(p) { return getParameterPname.has(p); } + }, + getBufferParameter : {}, // FIXME + getError : { + generate : function() { return []; } + }, + getFramebufferAttachmentParameter : {}, // FIXME + getProgramParameter : {}, // FIXME + getProgramInfoLog : {}, // FIXME + getRenderbufferParameter : {}, // FIXME + getShaderParameter : {}, // FIXME + getShaderInfoLog : {}, // FIXME + getShaderSource : {}, // FIXME + getTexParameter : {}, // FIXME + getUniform : {}, // FIXME + getUniformLocation : {}, // FIXME + getVertexAttrib : {}, // FIXME + getVertexAttribOffset : {}, // FIXME + +// H + + hint : { + generate : function() { return [GL.GENERATE_MIPMAP_HINT, mipmapHint.random()]; }, + checkValidArgs : function(h, m) { + return h == GL.GENERATE_MIPMAP_HINT && mipmapHint.has(m); + }, + teardown : function(){ GL.hint(GL.GENERATE_MIPMAP_HINT, GL.DONT_CARE); } + }, + +// I + + isBuffer : { + generate : function() { return [GL.createBuffer()]; }, + cleanup : function(o) { try { GL.deleteBuffer(o); } catch(e) {} } + }, + isEnabled : { + generate : function() { return [enableCap.random()]; }, + checkArgValidity : function(c) { return enableCap.has(c); } + }, + isFramebuffer : { + generate : function() { return [GL.createFramebuffer()]; }, + cleanup : function(o) { try { GL.deleteFramebuffer(o); } catch(e) {} } + }, + isProgram : { + generate : function() { return [GL.createProgram()]; }, + cleanup : function(o) { try { GL.deleteProgram(o); } catch(e) {} } + }, + isRenderbuffer : { + generate : function() { return [GL.createRenderbuffer()]; }, + cleanup : function(o) { try { GL.deleteRenderbuffer(o); } catch(e) {} } + }, + isShader : { + generate : function() { return [GL.createShader(shaderType.random())]; }, + cleanup : function(o) { try { GL.deleteShader(o); } catch(e) {} } + }, + isTexture : { + generate : function() { return [GL.createTexture()]; }, + cleanup : function(o) { try { GL.deleteTexture(o); } catch(e) {} } + }*/ + +}; diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-L_S.js b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-L_S.js new file mode 100644 index 0000000000..d3cdb3e67a --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-L_S.js @@ -0,0 +1,122 @@ +/* +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +*/ + +// ArgGenerators contains argument generators for WebGL functions. +// The argument generators are used for running random tests against the WebGL +// functions. +// +// ArgGenerators is an object consisting of functionName : argGen -properties. +// +// functionName is a WebGL context function name and the argGen is an argument +// generator object that encapsulates the requirements to run +// randomly generated tests on the WebGL function. +// +// An argGen object has the following methods: +// - setup -- set up state for testing the GL function, returns values +// that need cleanup in teardown. Run once before entering a +// test loop. +// - teardown -- do cleanup on setup's return values after testing is complete +// - generate -- generate a valid set of random arguments for the GL function +// - returnValueCleanup -- do cleanup on value returned by the tested GL function +// - cleanup -- do cleanup on generated arguments from generate +// - checkArgValidity -- check if passed args are valid. Has a call signature +// that matches generate's return value. Returns true +// if args are valid, false if not. +// +// Example test loop that demonstrates how the function args and return +// values flow together: +// +// var setupArgs = argGen.setup(); +// for (var i=0; i<numberOfTests; i++) { +// var generatedArgs = argGen.generate.apply(argGen, setupArgs); +// var validArgs = argGen.checkArgValidity.apply(argGen, generatedArgs); +// var rv = call the GL function with generatedArgs; +// argGen.returnValueCleanup(rv); +// argGen.cleanup.apply(argGen, generatedArgs); +// } +// argGen.teardown.apply(argGen, setupArgs); +// +ArgGenerators = { + +// GL functions in alphabetical order + +// L + + lineWidth : { + generate : function() { return [randomLineWidth()]; }, + teardown : function() { GL.lineWidth(1); } + }, + linkProgram : {}, // FIXME + +// P + pixelStorei : { + generate : function() { + return [pixelStoreiPname.random(), pixelStoreiParam.random()]; + }, + checkArgValidity : function(pname, param) { + return pixelStoreiPname.has(pname) && pixelStoreiParam.has(param); + }, + teardown : function() { + GL.pixelStorei(GL.PACK_ALIGNMENT, 4); + GL.pixelStorei(GL.UNPACK_ALIGNMENT, 4); + } + }, + polygonOffset : { + generate : function() { return [randomFloat(), randomFloat()]; }, + teardown : function() { GL.polygonOffset(0,0); } + }, + +// R + + readPixels : {}, // FIXME + renderbufferStorage : {}, // FIXME + +// S-1 + + sampleCoverage : { + generate : function() { return [randomFloatFromRange(0,1), randomBool()] }, + teardown : function() { GL.sampleCoverage(1, false); } + }, + scissor : { + generate : function() { + return [randomInt(3000)-1500, randomInt(3000)-1500, randomIntFromRange(0,3000), randomIntFromRange(0,3000)]; + }, + checkArgValidity : function(x,y,w,h) { + return castToInt(w) >= 0 && castToInt(h) >= 0; + }, + teardown : function() { + GL.scissor(0,0,GL.canvas.width, GL.canvas.height); + } + }, + shaderSource : {}, // FIXME + stencilFunc : { + generate : function(){ + return [stencilFuncFunc.random(), randomInt(MaxStencilValue), randomInt(0xffffffff)]; + }, + checkArgValidity : function(func, ref, mask) { + return stencilFuncFunc.has(func) && castToInt(ref) >= 0 && castToInt(ref) < MaxStencilValue; + }, + teardown : function() { + GL.stencilFunc(GL.ALWAYS, 0, 0xffffffff); + } + }, + stencilFuncSeparate : { + generate : function(){ + return [cullFace.random(), stencilFuncFunc.random(), randomInt(MaxStencilValue), randomInt(0xffffffff)]; + }, + checkArgValidity : function(face, func, ref, mask) { + return cullFace.has(face) && stencilFuncFunc.has(func) && castToInt(ref) >= 0 && castToInt(ref) < MaxStencilValue; + }, + teardown : function() { + GL.stencilFunc(GL.ALWAYS, 0, 0xffffffff); + } + }, + stencilMask : { + generate : function() { return [randomInt(0xffffffff)]; }, + teardown : function() { GL.stencilMask(0xffffffff); } + } + +}; diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-S_V.js b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-S_V.js new file mode 100644 index 0000000000..d08310001c --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/argGenerators-S_V.js @@ -0,0 +1,212 @@ +/* +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +*/ + +// ArgGenerators contains argument generators for WebGL functions. +// The argument generators are used for running random tests against the WebGL +// functions. +// +// ArgGenerators is an object consisting of functionName : argGen -properties. +// +// functionName is a WebGL context function name and the argGen is an argument +// generator object that encapsulates the requirements to run +// randomly generated tests on the WebGL function. +// +// An argGen object has the following methods: +// - setup -- set up state for testing the GL function, returns values +// that need cleanup in teardown. Run once before entering a +// test loop. +// - teardown -- do cleanup on setup's return values after testing is complete +// - generate -- generate a valid set of random arguments for the GL function +// - returnValueCleanup -- do cleanup on value returned by the tested GL function +// - cleanup -- do cleanup on generated arguments from generate +// - checkArgValidity -- check if passed args are valid. Has a call signature +// that matches generate's return value. Returns true +// if args are valid, false if not. +// +// Example test loop that demonstrates how the function args and return +// values flow together: +// +// var setupArgs = argGen.setup(); +// for (var i=0; i<numberOfTests; i++) { +// var generatedArgs = argGen.generate.apply(argGen, setupArgs); +// var validArgs = argGen.checkArgValidity.apply(argGen, generatedArgs); +// var rv = call the GL function with generatedArgs; +// argGen.returnValueCleanup(rv); +// argGen.cleanup.apply(argGen, generatedArgs); +// } +// argGen.teardown.apply(argGen, setupArgs); +// +ArgGenerators = { + +// GL functions in alphabetical order + +// S-2 + + stencilMaskSeparate : { + generate : function() { return [cullFace.random(), randomInt(0xffffffff)]; }, + checkArgValidity : function(face, mask) { + return cullFace.has(face); + }, + teardown : function() { GL.stencilMask(0xffffffff); } + }, + stencilOp : { + generate : function() { + return [stencilOp.random(), stencilOp.random(), stencilOp.random()]; + }, + checkArgValidity : function(sfail, dpfail, dppass) { + return stencilOp.has(sfail) && stencilOp.has(dpfail) && stencilOp.has(dppass); + }, + teardown : function() { GL.stencilOp(GL.KEEP, GL.KEEP, GL.KEEP); } + }, + stencilOpSeparate : { + generate : function() { + return [cullFace.random(), stencilOp.random(), stencilOp.random(), stencilOp.random()]; + }, + checkArgValidity : function(face, sfail, dpfail, dppass) { + return cullFace.has(face) && stencilOp.has(sfail) && + stencilOp.has(dpfail) && stencilOp.has(dppass); + }, + teardown : function() { GL.stencilOp(GL.KEEP, GL.KEEP, GL.KEEP); } + }, + +// T + texImage2D : { + noAlreadyTriedCheck : true, // Object.toSource is very slow here + setup : function() { + var tex = GL.createTexture(); + var tex2 = GL.createTexture(); + GL.bindTexture(GL.TEXTURE_2D, tex); + GL.bindTexture(GL.TEXTURE_CUBE_MAP, tex2); + return [tex, tex2]; + }, + generate : function() { + var format = texImageFormat.random(); + if (Math.random() < 0.5) { + var img = randomImage(16,16); + var a = [ texImageTarget.random(), 0, format, format, GL.UNSIGNED_BYTE, img ]; + return a; + } else { + var pix = null; + if (Math.random > 0.5) { + pix = new Uint8Array(16*16*4); + } + return [ + texImageTarget.random(), 0, + format, 16, 16, 0, + format, GL.UNSIGNED_BYTE, pix + ]; + } + }, + checkArgValidity : function(target, level, internalformat, width, height, border, format, type, data) { + // or : function(target, level, internalformat, format, type, image) + if (!texImageTarget.has(target) || castToInt(level) < 0) + return false; + if (arguments.length <= 6) { + var xformat = width; + var xtype = height; + var ximage = border; + if ((ximage instanceof HTMLImageElement || + ximage instanceof HTMLVideoElement || + ximage instanceof HTMLCanvasElement || + ximage instanceof ImageData) && + texImageInternalFormat.has(internalformat) && + texImageFormat.has(xformat) && + texImageType.has(xtype) && + internalformat == xformat) + return true; + return false; + } + var w = castToInt(width), h = castToInt(height), b = castToInt(border); + return texImageInternalFormat.has(internalformat) && w >= 0 && h >= 0 && + b == 0 && (data == null || data.byteLength == w*h*4) && + texImageFormat.has(format) && texImageType.has(type) + && internalformat == format; + }, + teardown : function(tex, tex2) { + GL.bindTexture(GL.TEXTURE_2D, null); + GL.bindTexture(GL.TEXTURE_CUBE_MAP, null); + GL.deleteTexture(tex); + GL.deleteTexture(tex2); + } + }, + texParameterf : { + generate : function() { + var pname = texParameterPname.random(); + var param = texParameterParam[pname].random(); + return [bindTextureTarget.random(), pname, param]; + }, + checkArgValidity : function(target, pname, param) { + if (!bindTextureTarget.has(target)) + return false; + if (!texParameterPname.has(pname)) + return false; + return texParameterParam[pname].has(param); + } + }, + texParameteri : { + generate : function() { + var pname = texParameterPname.random(); + var param = texParameterParam[pname].random(); + return [bindTextureTarget.random(), pname, param]; + }, + checkArgValidity : function(target, pname, param) { + if (!bindTextureTarget.has(target)) + return false; + if (!texParameterPname.has(pname)) + return false; + return texParameterParam[pname].has(param); + } + }, + texSubImage2D : {}, // FIXME + +// U + + uniform1f : {}, // FIXME + uniform1fv : {}, // FIXME + uniform1i : {}, // FIXME + uniform1iv : {}, // FIXME + uniform2f : {}, // FIXME + uniform2fv : {}, // FIXME + uniform2i : {}, // FIXME + uniform2iv : {}, // FIXME + uniform3f : {}, // FIXME + uniform3fv : {}, // FIXME + uniform3i : {}, // FIXME + uniform3iv : {}, // FIXME + uniform4f : {}, // FIXME + uniform4fv : {}, // FIXME + uniform4i : {}, // FIXME + uniform4iv : {}, // FIXME + uniformMatrix2fv : {}, // FIXME + uniformMatrix3fv : {}, // FIXME + uniformMatrix4fv : {}, // FIXME + useProgram : {}, // FIXME + +// V + + validateProgram : {}, // FIXME + vertexAttrib1f : {}, // FIXME + vertexAttrib1fv : {}, // FIXME + vertexAttrib2f : {}, // FIXME + vertexAttrib2fv : {}, // FIXME + vertexAttrib3f : {}, // FIXME + vertexAttrib3fv : {}, // FIXME + vertexAttrib4f : {}, // FIXME + vertexAttrib4fv : {}, // FIXME + vertexAttribPointer : {}, // FIXME + viewport : { + generate : function() { + return [randomInt(3000)-1500, randomInt(3000)-1500, randomIntFromRange(0,3000), randomIntFromRange(0,3000)]; + }, + checkArgValidity : function(x,y,w,h) { + return castToInt(w) >= 0 && castToInt(h) >= 0; + }, + teardown : function() { + GL.viewport(0,0,GL.canvas.width, GL.canvas.height); + } + } + +}; diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/badArgsArityLessThanArgc.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/badArgsArityLessThanArgc.html new file mode 100644 index 0000000000..5ee9727a6e --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/badArgsArityLessThanArgc.html @@ -0,0 +1,576 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> +<script type="application/javascript"> + +/* + The following tests are generated from + http://www.khronos.org/registry/gles/api/2.0/gl2.h + and api_modifications.txt +*/ +Tests.test_activeTexture = function(gl) { + assertFail(function(){ gl.activeTexture(); }); +} +Tests.test_attachShader = function(gl) { + assertFail(function(){ gl.attachShader(); }); + assertFail(function(){ gl.attachShader(0); }); +} +Tests.test_bindAttribLocation = function(gl) { + assertFail(function(){ gl.bindAttribLocation(); }); + assertFail(function(){ gl.bindAttribLocation(0); }); + assertFail(function(){ gl.bindAttribLocation(0,0); }); +} +Tests.test_bindBuffer = function(gl) { + assertFail(function(){ gl.bindBuffer(); }); + assertFail(function(){ gl.bindBuffer(0); }); +} +Tests.test_bindFramebuffer = function(gl) { + assertFail(function(){ gl.bindFramebuffer(); }); + assertFail(function(){ gl.bindFramebuffer(0); }); +} +Tests.test_bindRenderbuffer = function(gl) { + assertFail(function(){ gl.bindRenderbuffer(); }); + assertFail(function(){ gl.bindRenderbuffer(0); }); +} +Tests.test_bindTexture = function(gl) { + assertFail(function(){ gl.bindTexture(); }); + assertFail(function(){ gl.bindTexture(0); }); +} +Tests.test_blendColor = function(gl) { + assertFail(function(){ gl.blendColor(); }); + assertFail(function(){ gl.blendColor(0); }); + assertFail(function(){ gl.blendColor(0,0); }); + assertFail(function(){ gl.blendColor(0,0,0); }); +} +Tests.test_blendEquation = function(gl) { + assertFail(function(){ gl.blendEquation(); }); +} +Tests.test_blendEquationSeparate = function(gl) { + assertFail(function(){ gl.blendEquationSeparate(); }); + assertFail(function(){ gl.blendEquationSeparate(0); }); +} +Tests.test_blendFunc = function(gl) { + assertFail(function(){ gl.blendFunc(); }); + assertFail(function(){ gl.blendFunc(0); }); +} +Tests.test_blendFuncSeparate = function(gl) { + assertFail(function(){ gl.blendFuncSeparate(); }); + assertFail(function(){ gl.blendFuncSeparate(0); }); + assertFail(function(){ gl.blendFuncSeparate(0,0); }); + assertFail(function(){ gl.blendFuncSeparate(0,0,0); }); +} +Tests.test_bufferData = function(gl) { + assertFail(function(){ gl.bufferData(); }); + assertFail(function(){ gl.bufferData(0); }); + assertFail(function(){ gl.bufferData(0,0); }); +} +Tests.test_bufferSubData = function(gl) { + assertFail(function(){ gl.bufferSubData(); }); + assertFail(function(){ gl.bufferSubData(0); }); + assertFail(function(){ gl.bufferSubData(0,0); }); +} +Tests.test_checkFramebufferStatus = function(gl) { + assertFail(function(){ gl.checkFramebufferStatus(); }); +} +Tests.test_clear = function(gl) { + assertFail(function(){ gl.clear(); }); +} +Tests.test_clearColor = function(gl) { + assertFail(function(){ gl.clearColor(); }); + assertFail(function(){ gl.clearColor(0); }); + assertFail(function(){ gl.clearColor(0,0); }); + assertFail(function(){ gl.clearColor(0,0,0); }); +} +Tests.test_clearDepth = function(gl) { + assertFail(function(){ gl.clearDepth(); }); +} +Tests.test_clearStencil = function(gl) { + assertFail(function(){ gl.clearStencil(); }); +} +Tests.test_colorMask = function(gl) { + assertFail(function(){ gl.colorMask(); }); + assertFail(function(){ gl.colorMask(0); }); + assertFail(function(){ gl.colorMask(0,0); }); + assertFail(function(){ gl.colorMask(0,0,0); }); +} +Tests.test_compileShader = function(gl) { + assertFail(function(){ gl.compileShader(); }); +} +Tests.test_copyTexImage2D = function(gl) { + assertFail(function(){ gl.copyTexImage2D(); }); + assertFail(function(){ gl.copyTexImage2D(0); }); + assertFail(function(){ gl.copyTexImage2D(0,0); }); + assertFail(function(){ gl.copyTexImage2D(0,0,0); }); + assertFail(function(){ gl.copyTexImage2D(0,0,0,0); }); + assertFail(function(){ gl.copyTexImage2D(0,0,0,0,0); }); + assertFail(function(){ gl.copyTexImage2D(0,0,0,0,0,0); }); + assertFail(function(){ gl.copyTexImage2D(0,0,0,0,0,0,0); }); +} +Tests.test_copyTexSubImage2D = function(gl) { + assertFail(function(){ gl.copyTexSubImage2D(); }); + assertFail(function(){ gl.copyTexSubImage2D(0); }); + assertFail(function(){ gl.copyTexSubImage2D(0,0); }); + assertFail(function(){ gl.copyTexSubImage2D(0,0,0); }); + assertFail(function(){ gl.copyTexSubImage2D(0,0,0,0); }); + assertFail(function(){ gl.copyTexSubImage2D(0,0,0,0,0); }); + assertFail(function(){ gl.copyTexSubImage2D(0,0,0,0,0,0); }); + assertFail(function(){ gl.copyTexSubImage2D(0,0,0,0,0,0,0); }); +} +Tests.test_createProgram = function(gl) { +} +Tests.test_createShader = function(gl) { + assertFail(function(){ gl.createShader(); }); +} +Tests.test_cullFace = function(gl) { + assertFail(function(){ gl.cullFace(); }); +} +Tests.test_deleteBuffer = function(gl) { + assertFail(function(){ gl.deleteBuffer(); }); +} +Tests.test_deleteFramebuffer = function(gl) { + assertFail(function(){ gl.deleteFramebuffer(); }); +} +Tests.test_deleteProgram = function(gl) { + assertFail(function(){ gl.deleteProgram(); }); +} +Tests.test_deleteRenderbuffer = function(gl) { + assertFail(function(){ gl.deleteRenderbuffer(); }); +} +Tests.test_deleteShader = function(gl) { + assertFail(function(){ gl.deleteShader(); }); +} +Tests.test_deleteTexture = function(gl) { + assertFail(function(){ gl.deleteTexture(); }); +} +Tests.test_depthFunc = function(gl) { + assertFail(function(){ gl.depthFunc(); }); +} +Tests.test_depthMask = function(gl) { + assertFail(function(){ gl.depthMask(); }); +} +Tests.test_depthRange = function(gl) { + assertFail(function(){ gl.depthRange(); }); + assertFail(function(){ gl.depthRange(0); }); +} +Tests.test_detachShader = function(gl) { + assertFail(function(){ gl.detachShader(); }); + assertFail(function(){ gl.detachShader(0); }); +} +Tests.test_disable = function(gl) { + assertFail(function(){ gl.disable(); }); +} +Tests.test_disableVertexAttribArray = function(gl) { + assertFail(function(){ gl.disableVertexAttribArray(); }); +} +Tests.test_drawArrays = function(gl) { + assertFail(function(){ gl.drawArrays(); }); + assertFail(function(){ gl.drawArrays(0); }); + assertFail(function(){ gl.drawArrays(0,0); }); +} +Tests.test_drawElements = function(gl) { + assertFail(function(){ gl.drawElements(); }); + assertFail(function(){ gl.drawElements(0); }); + assertFail(function(){ gl.drawElements(0,0); }); + assertFail(function(){ gl.drawElements(0,0,0); }); +} +Tests.test_enable = function(gl) { + assertFail(function(){ gl.enable(); }); +} +Tests.test_enableVertexAttribArray = function(gl) { + assertFail(function(){ gl.enableVertexAttribArray(); }); +} +Tests.test_finish = function(gl) { +} +Tests.test_flush = function(gl) { +} +Tests.test_framebufferRenderbuffer = function(gl) { + assertFail(function(){ gl.framebufferRenderbuffer(); }); + assertFail(function(){ gl.framebufferRenderbuffer(0); }); + assertFail(function(){ gl.framebufferRenderbuffer(0,0); }); + assertFail(function(){ gl.framebufferRenderbuffer(0,0,0); }); +} +Tests.test_framebufferTexture2D = function(gl) { + assertFail(function(){ gl.framebufferTexture2D(); }); + assertFail(function(){ gl.framebufferTexture2D(0); }); + assertFail(function(){ gl.framebufferTexture2D(0,0); }); + assertFail(function(){ gl.framebufferTexture2D(0,0,0); }); + assertFail(function(){ gl.framebufferTexture2D(0,0,0,0); }); +} +Tests.test_frontFace = function(gl) { + assertFail(function(){ gl.frontFace(); }); +} +Tests.test_createBuffer = function(gl) { +} +Tests.test_generateMipmap = function(gl) { + assertFail(function(){ gl.generateMipmap(); }); +} +Tests.test_createFramebuffer = function(gl) { +} +Tests.test_createRenderbuffer = function(gl) { +} +Tests.test_createTexture = function(gl) { +} +Tests.test_getActiveAttrib = function(gl) { + assertFail(function(){ gl.getActiveAttrib(); }); + assertFail(function(){ gl.getActiveAttrib(0); }); +} +Tests.test_getActiveUniform = function(gl) { + assertFail(function(){ gl.getActiveUniform(); }); + assertFail(function(){ gl.getActiveUniform(0); }); +} +Tests.test_getAttachedShaders = function(gl) { + assertFail(function(){ gl.getAttachedShaders(); }); +} +Tests.test_getAttribLocation = function(gl) { + assertFail(function(){ gl.getAttribLocation(); }); + assertFail(function(){ gl.getAttribLocation(0); }); +} +Tests.test_getBufferParameteri = function(gl) { + assertFail(function(){ gl.getBufferParameteri(); }); + assertFail(function(){ gl.getBufferParameteri(0); }); +} +Tests.test_getError = function(gl) { +} +Tests.test_getFramebufferAttachmentParameteri = function(gl) { + assertFail(function(){ gl.getFramebufferAttachmentParameteri(); }); + assertFail(function(){ gl.getFramebufferAttachmentParameteri(0); }); + assertFail(function(){ gl.getFramebufferAttachmentParameteri(0,0); }); +} +Tests.test_getProgramInfoLog = function(gl) { + assertFail(function(){ gl.getProgramInfoLog(); }); +} +Tests.test_getRenderbufferParameteri = function(gl) { + assertFail(function(){ gl.getRenderbufferParameteri(); }); + assertFail(function(){ gl.getRenderbufferParameteri(0); }); +} +Tests.test_getShaderInfoLog = function(gl) { + assertFail(function(){ gl.getShaderInfoLog(); }); +} +Tests.test_getShaderSource = function(gl) { + assertFail(function(){ gl.getShaderSource(); }); +} +Tests.test_getUniformLocation = function(gl) { + assertFail(function(){ gl.getUniformLocation(); }); + assertFail(function(){ gl.getUniformLocation(0); }); +} +Tests.test_hint = function(gl) { + assertFail(function(){ gl.hint(); }); + assertFail(function(){ gl.hint(0); }); +} +Tests.test_isBuffer = function(gl) { + assertFail(function(){ gl.isBuffer(); }); +} +Tests.test_isEnabled = function(gl) { + assertFail(function(){ gl.isEnabled(); }); +} +Tests.test_isFramebuffer = function(gl) { + assertFail(function(){ gl.isFramebuffer(); }); +} +Tests.test_isProgram = function(gl) { + assertFail(function(){ gl.isProgram(); }); +} +Tests.test_isRenderbuffer = function(gl) { + assertFail(function(){ gl.isRenderbuffer(); }); +} +Tests.test_isShader = function(gl) { + assertFail(function(){ gl.isShader(); }); +} +Tests.test_isTexture = function(gl) { + assertFail(function(){ gl.isTexture(); }); +} +Tests.test_lineWidth = function(gl) { + assertFail(function(){ gl.lineWidth(); }); +} +Tests.test_linkProgram = function(gl) { + assertFail(function(){ gl.linkProgram(); }); +} +Tests.test_polygonOffset = function(gl) { + assertFail(function(){ gl.polygonOffset(); }); + assertFail(function(){ gl.polygonOffset(0); }); +} +Tests.test_readPixels = function(gl) { + assertFail(function(){ gl.readPixels(); }); + assertFail(function(){ gl.readPixels(0); }); + assertFail(function(){ gl.readPixels(0,0); }); + assertFail(function(){ gl.readPixels(0,0,0); }); + assertFail(function(){ gl.readPixels(0,0,0,0); }); + assertFail(function(){ gl.readPixels(0,0,0,0,0); }); +} +Tests.test_renderbufferStorage = function(gl) { + assertFail(function(){ gl.renderbufferStorage(); }); + assertFail(function(){ gl.renderbufferStorage(0); }); + assertFail(function(){ gl.renderbufferStorage(0,0); }); + assertFail(function(){ gl.renderbufferStorage(0,0,0); }); +} +Tests.test_sampleCoverage = function(gl) { + assertFail(function(){ gl.sampleCoverage(); }); + assertFail(function(){ gl.sampleCoverage(0); }); +} +Tests.test_scissor = function(gl) { + assertFail(function(){ gl.scissor(); }); + assertFail(function(){ gl.scissor(0); }); + assertFail(function(){ gl.scissor(0,0); }); + assertFail(function(){ gl.scissor(0,0,0); }); +} +Tests.test_shaderSource = function(gl) { + assertFail(function(){ gl.shaderSource(); }); + assertFail(function(){ gl.shaderSource(0); }); +} +Tests.test_stencilFunc = function(gl) { + assertFail(function(){ gl.stencilFunc(); }); + assertFail(function(){ gl.stencilFunc(0); }); + assertFail(function(){ gl.stencilFunc(0,0); }); +} +Tests.test_stencilFuncSeparate = function(gl) { + assertFail(function(){ gl.stencilFuncSeparate(); }); + assertFail(function(){ gl.stencilFuncSeparate(0); }); + assertFail(function(){ gl.stencilFuncSeparate(0,0); }); + assertFail(function(){ gl.stencilFuncSeparate(0,0,0); }); +} +Tests.test_stencilMask = function(gl) { + assertFail(function(){ gl.stencilMask(); }); +} +Tests.test_stencilMaskSeparate = function(gl) { + assertFail(function(){ gl.stencilMaskSeparate(); }); + assertFail(function(){ gl.stencilMaskSeparate(0); }); +} +Tests.test_stencilOp = function(gl) { + assertFail(function(){ gl.stencilOp(); }); + assertFail(function(){ gl.stencilOp(0); }); + assertFail(function(){ gl.stencilOp(0,0); }); +} +Tests.test_stencilOpSeparate = function(gl) { + assertFail(function(){ gl.stencilOpSeparate(); }); + assertFail(function(){ gl.stencilOpSeparate(0); }); + assertFail(function(){ gl.stencilOpSeparate(0,0); }); + assertFail(function(){ gl.stencilOpSeparate(0,0,0); }); +} +Tests.test_texImage2D = function(gl) { + assertFail(function(){ gl.texImage2D(); }); + assertFail(function(){ gl.texImage2D(0); }); + assertFail(function(){ gl.texImage2D(0,0); }); +} +Tests.test_texParameteri = function(gl) { + assertFail(function(){ gl.texParameteri(); }); + assertFail(function(){ gl.texParameteri(0); }); + assertFail(function(){ gl.texParameteri(0,0); }); +} +Tests.test_texSubImage2D = function(gl) { + assertFail(function(){ gl.texSubImage2D(); }); + assertFail(function(){ gl.texSubImage2D(0); }); + assertFail(function(){ gl.texSubImage2D(0,0); }); + assertFail(function(){ gl.texSubImage2D(0,0,0); }); + assertFail(function(){ gl.texSubImage2D(0,0,0,0); }); + assertFail(function(){ gl.texSubImage2D(0,0,0,0,0); }); + assertFail(function(){ gl.texSubImage2D(0,0,0,0,0,0); }); + assertFail(function(){ gl.texSubImage2D(0,0,0,0,0,0,0); }); + assertFail(function(){ gl.texSubImage2D(0,0,0,0,0,0,0,0); }); +} +Tests.test_uniform1f = function(gl) { + assertFail(function(){ gl.uniform1f(); }); + assertFail(function(){ gl.uniform1f(0); }); +} +Tests.test_uniform1fv = function(gl) { + assertFail(function(){ gl.uniform1fv(); }); + assertFail(function(){ gl.uniform1fv(0); }); +} +Tests.test_uniform1i = function(gl) { + assertFail(function(){ gl.uniform1i(); }); + assertFail(function(){ gl.uniform1i(0); }); +} +Tests.test_uniform1iv = function(gl) { + assertFail(function(){ gl.uniform1iv(); }); + assertFail(function(){ gl.uniform1iv(0); }); +} +Tests.test_uniform2f = function(gl) { + assertFail(function(){ gl.uniform2f(); }); + assertFail(function(){ gl.uniform2f(0); }); + assertFail(function(){ gl.uniform2f(0,0); }); +} +Tests.test_uniform2fv = function(gl) { + assertFail(function(){ gl.uniform2fv(); }); + assertFail(function(){ gl.uniform2fv(0); }); +} +Tests.test_uniform2i = function(gl) { + assertFail(function(){ gl.uniform2i(); }); + assertFail(function(){ gl.uniform2i(0); }); + assertFail(function(){ gl.uniform2i(0,0); }); +} +Tests.test_uniform2iv = function(gl) { + assertFail(function(){ gl.uniform2iv(); }); + assertFail(function(){ gl.uniform2iv(0); }); +} +Tests.test_uniform3f = function(gl) { + assertFail(function(){ gl.uniform3f(); }); + assertFail(function(){ gl.uniform3f(0); }); + assertFail(function(){ gl.uniform3f(0,0); }); + assertFail(function(){ gl.uniform3f(0,0,0); }); +} +Tests.test_uniform3fv = function(gl) { + assertFail(function(){ gl.uniform3fv(); }); + assertFail(function(){ gl.uniform3fv(0); }); +} +Tests.test_uniform3i = function(gl) { + assertFail(function(){ gl.uniform3i(); }); + assertFail(function(){ gl.uniform3i(0); }); + assertFail(function(){ gl.uniform3i(0,0); }); + assertFail(function(){ gl.uniform3i(0,0,0); }); +} +Tests.test_uniform3iv = function(gl) { + assertFail(function(){ gl.uniform3iv(); }); + assertFail(function(){ gl.uniform3iv(0); }); +} +Tests.test_uniform4f = function(gl) { + assertFail(function(){ gl.uniform4f(); }); + assertFail(function(){ gl.uniform4f(0); }); + assertFail(function(){ gl.uniform4f(0,0); }); + assertFail(function(){ gl.uniform4f(0,0,0); }); + assertFail(function(){ gl.uniform4f(0,0,0,0); }); +} +Tests.test_uniform4fv = function(gl) { + assertFail(function(){ gl.uniform4fv(); }); + assertFail(function(){ gl.uniform4fv(0); }); +} +Tests.test_uniform4i = function(gl) { + assertFail(function(){ gl.uniform4i(); }); + assertFail(function(){ gl.uniform4i(0); }); + assertFail(function(){ gl.uniform4i(0,0); }); + assertFail(function(){ gl.uniform4i(0,0,0); }); + assertFail(function(){ gl.uniform4i(0,0,0,0); }); +} +Tests.test_uniform4iv = function(gl) { + assertFail(function(){ gl.uniform4iv(); }); + assertFail(function(){ gl.uniform4iv(0); }); +} +Tests.test_uniformMatrix2fv = function(gl) { + assertFail(function(){ gl.uniformMatrix2fv(); }); + assertFail(function(){ gl.uniformMatrix2fv(0); }); + assertFail(function(){ gl.uniformMatrix2fv(0,0); }); +} +Tests.test_uniformMatrix3fv = function(gl) { + assertFail(function(){ gl.uniformMatrix3fv(); }); + assertFail(function(){ gl.uniformMatrix3fv(0); }); + assertFail(function(){ gl.uniformMatrix3fv(0,0); }); +} +Tests.test_uniformMatrix4fv = function(gl) { + assertFail(function(){ gl.uniformMatrix4fv(); }); + assertFail(function(){ gl.uniformMatrix4fv(0); }); + assertFail(function(){ gl.uniformMatrix4fv(0,0); }); +} +Tests.test_useProgram = function(gl) { + assertFail(function(){ gl.useProgram(); }); +} +Tests.test_validateProgram = function(gl) { + assertFail(function(){ gl.validateProgram(); }); +} +Tests.test_vertexAttrib1f = function(gl) { + assertFail(function(){ gl.vertexAttrib1f(); }); + assertFail(function(){ gl.vertexAttrib1f(0); }); +} +Tests.test_vertexAttrib1fv = function(gl) { + assertFail(function(){ gl.vertexAttrib1fv(); }); + assertFail(function(){ gl.vertexAttrib1fv(0); }); +} +Tests.test_vertexAttrib2f = function(gl) { + assertFail(function(){ gl.vertexAttrib2f(); }); + assertFail(function(){ gl.vertexAttrib2f(0); }); + assertFail(function(){ gl.vertexAttrib2f(0,0); }); +} +Tests.test_vertexAttrib2fv = function(gl) { + assertFail(function(){ gl.vertexAttrib2fv(); }); + assertFail(function(){ gl.vertexAttrib2fv(0); }); +} +Tests.test_vertexAttrib3f = function(gl) { + assertFail(function(){ gl.vertexAttrib3f(); }); + assertFail(function(){ gl.vertexAttrib3f(0); }); + assertFail(function(){ gl.vertexAttrib3f(0,0); }); + assertFail(function(){ gl.vertexAttrib3f(0,0,0); }); +} +Tests.test_vertexAttrib3fv = function(gl) { + assertFail(function(){ gl.vertexAttrib3fv(); }); + assertFail(function(){ gl.vertexAttrib3fv(0); }); +} +Tests.test_vertexAttrib4f = function(gl) { + assertFail(function(){ gl.vertexAttrib4f(); }); + assertFail(function(){ gl.vertexAttrib4f(0); }); + assertFail(function(){ gl.vertexAttrib4f(0,0); }); + assertFail(function(){ gl.vertexAttrib4f(0,0,0); }); + assertFail(function(){ gl.vertexAttrib4f(0,0,0,0); }); +} +Tests.test_vertexAttrib4fv = function(gl) { + assertFail(function(){ gl.vertexAttrib4fv(); }); + assertFail(function(){ gl.vertexAttrib4fv(0); }); +} +Tests.test_vertexAttribPointer = function(gl) { + assertFail(function(){ gl.vertexAttribPointer(); }); + assertFail(function(){ gl.vertexAttribPointer(0); }); + assertFail(function(){ gl.vertexAttribPointer(0,0); }); + assertFail(function(){ gl.vertexAttribPointer(0,0,0); }); + assertFail(function(){ gl.vertexAttribPointer(0,0,0,0); }); + assertFail(function(){ gl.vertexAttribPointer(0,0,0,0,0); }); +} +Tests.test_viewport = function(gl) { + assertFail(function(){ gl.viewport(); }); + assertFail(function(){ gl.viewport(0); }); + assertFail(function(){ gl.viewport(0,0); }); + assertFail(function(){ gl.viewport(0,0,0); }); +} +Tests.test_currentArrayBufferBinding = function(gl) { +} +Tests.test_currentElementArrayBufferBinding = function(gl) { +} +Tests.test_currentFramebufferBinding = function(gl) { +} +Tests.test_currentRenderbufferBinding = function(gl) { +} +Tests.test_currentTextureBinding2D = function(gl) { +} +Tests.test_currentTextureBindingCubeMap = function(gl) { +} +Tests.test_currentProgram = function(gl) { +} +Tests.test_getParameter = function(gl) { + assertFail(function(){ gl.getParameter(); }); +} +Tests.test_getProgramParameter = function(gl) { + assertFail(function(){ gl.getProgramParameter(); }); + assertFail(function(){ gl.getProgramParameter(0); }); +} +Tests.test_getShaderParameter = function(gl) { + assertFail(function(){ gl.getShaderParameter(); }); + assertFail(function(){ gl.getShaderParameter(0); }); +} +Tests.test_getTexParameteri = function(gl) { + assertFail(function(){ gl.getTexParameteri(); }); + assertFail(function(){ gl.getTexParameteri(0); }); +} +Tests.test_getUniformi = function(gl) { + assertFail(function(){ gl.getUniformi(); }); + assertFail(function(){ gl.getUniformi(0); }); +} +Tests.test_getVertexAttribi = function(gl) { + assertFail(function(){ gl.getVertexAttribi(); }); + assertFail(function(){ gl.getVertexAttribi(0); }); +} +Tests.test_present = function(gl) { +} +Tests.startUnit = function() { + var canvas = document.getElementById('gl'); + var gl = wrapGLContext(getGLContext(canvas)); + return [gl]; +} + +</script> +<style>canvas{ position:absolute; }</style> +</head><body> + <canvas id="gl" width="1" height="1"></canvas> +</body></html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/constants.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/constants.html new file mode 100644 index 0000000000..61997afae6 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/constants.html @@ -0,0 +1,350 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> +<script type="application/javascript"> + +/* + The following tests are generated from + http://www.khronos.org/registry/gles/api/2.0/gl2.h + and api_modifications.txt +*/ +var constants = { +DEPTH_BUFFER_BIT : 0x00000100, +STENCIL_BUFFER_BIT : 0x00000400, +COLOR_BUFFER_BIT : 0x00004000, +POINTS : 0x0000, +LINES : 0x0001, +LINE_LOOP : 0x0002, +LINE_STRIP : 0x0003, +TRIANGLES : 0x0004, +TRIANGLE_STRIP : 0x0005, +TRIANGLE_FAN : 0x0006, +ZERO : 0, +ONE : 1, +SRC_COLOR : 0x0300, +ONE_MINUS_SRC_COLOR : 0x0301, +SRC_ALPHA : 0x0302, +ONE_MINUS_SRC_ALPHA : 0x0303, +DST_ALPHA : 0x0304, +ONE_MINUS_DST_ALPHA : 0x0305, +DST_COLOR : 0x0306, +ONE_MINUS_DST_COLOR : 0x0307, +SRC_ALPHA_SATURATE : 0x0308, +FUNC_ADD : 0x8006, +BLEND_EQUATION : 0x8009, +BLEND_EQUATION_RGB : 0x8009, +BLEND_EQUATION_ALPHA : 0x883D, +FUNC_SUBTRACT : 0x800A, +FUNC_REVERSE_SUBTRACT : 0x800B, +BLEND_DST_RGB : 0x80C8, +BLEND_SRC_RGB : 0x80C9, +BLEND_DST_ALPHA : 0x80CA, +BLEND_SRC_ALPHA : 0x80CB, +CONSTANT_COLOR : 0x8001, +ONE_MINUS_CONSTANT_COLOR : 0x8002, +CONSTANT_ALPHA : 0x8003, +ONE_MINUS_CONSTANT_ALPHA : 0x8004, +BLEND_COLOR : 0x8005, +ARRAY_BUFFER : 0x8892, +ELEMENT_ARRAY_BUFFER : 0x8893, +ARRAY_BUFFER_BINDING : 0x8894, +ELEMENT_ARRAY_BUFFER_BINDING : 0x8895, +STREAM_DRAW : 0x88E0, +STATIC_DRAW : 0x88E4, +DYNAMIC_DRAW : 0x88E8, +BUFFER_SIZE : 0x8764, +BUFFER_USAGE : 0x8765, +CURRENT_VERTEX_ATTRIB : 0x8626, +FRONT : 0x0404, +BACK : 0x0405, +FRONT_AND_BACK : 0x0408, +TEXTURE_2D : 0x0DE1, +CULL_FACE : 0x0B44, +BLEND : 0x0BE2, +DITHER : 0x0BD0, +STENCIL_TEST : 0x0B90, +DEPTH_TEST : 0x0B71, +SCISSOR_TEST : 0x0C11, +POLYGON_OFFSET_FILL : 0x8037, +SAMPLE_ALPHA_TO_COVERAGE : 0x809E, +SAMPLE_COVERAGE : 0x80A0, +NO_ERROR : 0, +INVALID_ENUM : 0x0500, +INVALID_VALUE : 0x0501, +INVALID_OPERATION : 0x0502, +OUT_OF_MEMORY : 0x0505, +CW : 0x0900, +CCW : 0x0901, +LINE_WIDTH : 0x0B21, +ALIASED_POINT_SIZE_RANGE : 0x846D, +ALIASED_LINE_WIDTH_RANGE : 0x846E, +CULL_FACE_MODE : 0x0B45, +FRONT_FACE : 0x0B46, +DEPTH_RANGE : 0x0B70, +DEPTH_WRITEMASK : 0x0B72, +DEPTH_CLEAR_VALUE : 0x0B73, +DEPTH_FUNC : 0x0B74, +STENCIL_CLEAR_VALUE : 0x0B91, +STENCIL_FUNC : 0x0B92, +STENCIL_FAIL : 0x0B94, +STENCIL_PASS_DEPTH_FAIL : 0x0B95, +STENCIL_PASS_DEPTH_PASS : 0x0B96, +STENCIL_REF : 0x0B97, +STENCIL_VALUE_MASK : 0x0B93, +STENCIL_WRITEMASK : 0x0B98, +STENCIL_BACK_FUNC : 0x8800, +STENCIL_BACK_FAIL : 0x8801, +STENCIL_BACK_PASS_DEPTH_FAIL : 0x8802, +STENCIL_BACK_PASS_DEPTH_PASS : 0x8803, +STENCIL_BACK_REF : 0x8CA3, +STENCIL_BACK_VALUE_MASK : 0x8CA4, +STENCIL_BACK_WRITEMASK : 0x8CA5, +VIEWPORT : 0x0BA2, +SCISSOR_BOX : 0x0C10, +COLOR_CLEAR_VALUE : 0x0C22, +COLOR_WRITEMASK : 0x0C23, +UNPACK_ALIGNMENT : 0x0CF5, +PACK_ALIGNMENT : 0x0D05, +MAX_TEXTURE_SIZE : 0x0D33, +MAX_VIEWPORT_DIMS : 0x0D3A, +SUBPIXEL_BITS : 0x0D50, +RED_BITS : 0x0D52, +GREEN_BITS : 0x0D53, +BLUE_BITS : 0x0D54, +ALPHA_BITS : 0x0D55, +DEPTH_BITS : 0x0D56, +STENCIL_BITS : 0x0D57, +POLYGON_OFFSET_UNITS : 0x2A00, +POLYGON_OFFSET_FACTOR : 0x8038, +TEXTURE_BINDING_2D : 0x8069, +SAMPLE_BUFFERS : 0x80A8, +SAMPLES : 0x80A9, +SAMPLE_COVERAGE_VALUE : 0x80AA, +SAMPLE_COVERAGE_INVERT : 0x80AB, +COMPRESSED_TEXTURE_FORMATS : 0x86A3, +DONT_CARE : 0x1100, +FASTEST : 0x1101, +NICEST : 0x1102, +GENERATE_MIPMAP_HINT : 0x8192, +BYTE : 0x1400, +UNSIGNED_BYTE : 0x1401, +SHORT : 0x1402, +UNSIGNED_SHORT : 0x1403, +INT : 0x1404, +UNSIGNED_INT : 0x1405, +FLOAT : 0x1406, +//FIXED : 0x140C, +DEPTH_COMPONENT : 0x1902, +ALPHA : 0x1906, +RGB : 0x1907, +RGBA : 0x1908, +LUMINANCE : 0x1909, +LUMINANCE_ALPHA : 0x190A, +UNSIGNED_SHORT_4_4_4_4 : 0x8033, +UNSIGNED_SHORT_5_5_5_1 : 0x8034, +UNSIGNED_SHORT_5_6_5 : 0x8363, +FRAGMENT_SHADER : 0x8B30, +VERTEX_SHADER : 0x8B31, +MAX_VERTEX_ATTRIBS : 0x8869, +MAX_VERTEX_UNIFORM_VECTORS : 0x8DFB, +MAX_VARYING_VECTORS : 0x8DFC, +MAX_COMBINED_TEXTURE_IMAGE_UNITS : 0x8B4D, +MAX_VERTEX_TEXTURE_IMAGE_UNITS : 0x8B4C, +MAX_TEXTURE_IMAGE_UNITS : 0x8872, +MAX_FRAGMENT_UNIFORM_VECTORS : 0x8DFD, +SHADER_TYPE : 0x8B4F, +DELETE_STATUS : 0x8B80, +LINK_STATUS : 0x8B82, +VALIDATE_STATUS : 0x8B83, +ATTACHED_SHADERS : 0x8B85, +ACTIVE_UNIFORMS : 0x8B86, +ACTIVE_ATTRIBUTES : 0x8B89, +SHADING_LANGUAGE_VERSION : 0x8B8C, +CURRENT_PROGRAM : 0x8B8D, +NEVER : 0x0200, +LESS : 0x0201, +EQUAL : 0x0202, +LEQUAL : 0x0203, +GREATER : 0x0204, +NOTEQUAL : 0x0205, +GEQUAL : 0x0206, +ALWAYS : 0x0207, +KEEP : 0x1E00, +REPLACE : 0x1E01, +INCR : 0x1E02, +DECR : 0x1E03, +INVERT : 0x150A, +INCR_WRAP : 0x8507, +DECR_WRAP : 0x8508, +VENDOR : 0x1F00, +RENDERER : 0x1F01, +VERSION : 0x1F02, +//EXTENSIONS : 0x1F03, +NEAREST : 0x2600, +LINEAR : 0x2601, +NEAREST_MIPMAP_NEAREST : 0x2700, +LINEAR_MIPMAP_NEAREST : 0x2701, +NEAREST_MIPMAP_LINEAR : 0x2702, +LINEAR_MIPMAP_LINEAR : 0x2703, +TEXTURE_MAG_FILTER : 0x2800, +TEXTURE_MIN_FILTER : 0x2801, +TEXTURE_WRAP_S : 0x2802, +TEXTURE_WRAP_T : 0x2803, +TEXTURE : 0x1702, +TEXTURE_CUBE_MAP : 0x8513, +TEXTURE_BINDING_CUBE_MAP : 0x8514, +TEXTURE_CUBE_MAP_POSITIVE_X : 0x8515, +TEXTURE_CUBE_MAP_NEGATIVE_X : 0x8516, +TEXTURE_CUBE_MAP_POSITIVE_Y : 0x8517, +TEXTURE_CUBE_MAP_NEGATIVE_Y : 0x8518, +TEXTURE_CUBE_MAP_POSITIVE_Z : 0x8519, +TEXTURE_CUBE_MAP_NEGATIVE_Z : 0x851A, +MAX_CUBE_MAP_TEXTURE_SIZE : 0x851C, +TEXTURE0 : 0x84C0, +TEXTURE1 : 0x84C1, +TEXTURE2 : 0x84C2, +TEXTURE3 : 0x84C3, +TEXTURE4 : 0x84C4, +TEXTURE5 : 0x84C5, +TEXTURE6 : 0x84C6, +TEXTURE7 : 0x84C7, +TEXTURE8 : 0x84C8, +TEXTURE9 : 0x84C9, +TEXTURE10 : 0x84CA, +TEXTURE11 : 0x84CB, +TEXTURE12 : 0x84CC, +TEXTURE13 : 0x84CD, +TEXTURE14 : 0x84CE, +TEXTURE15 : 0x84CF, +TEXTURE16 : 0x84D0, +TEXTURE17 : 0x84D1, +TEXTURE18 : 0x84D2, +TEXTURE19 : 0x84D3, +TEXTURE20 : 0x84D4, +TEXTURE21 : 0x84D5, +TEXTURE22 : 0x84D6, +TEXTURE23 : 0x84D7, +TEXTURE24 : 0x84D8, +TEXTURE25 : 0x84D9, +TEXTURE26 : 0x84DA, +TEXTURE27 : 0x84DB, +TEXTURE28 : 0x84DC, +TEXTURE29 : 0x84DD, +TEXTURE30 : 0x84DE, +TEXTURE31 : 0x84DF, +ACTIVE_TEXTURE : 0x84E0, +REPEAT : 0x2901, +CLAMP_TO_EDGE : 0x812F, +MIRRORED_REPEAT : 0x8370, +FLOAT_VEC2 : 0x8B50, +FLOAT_VEC3 : 0x8B51, +FLOAT_VEC4 : 0x8B52, +INT_VEC2 : 0x8B53, +INT_VEC3 : 0x8B54, +INT_VEC4 : 0x8B55, +BOOL : 0x8B56, +BOOL_VEC2 : 0x8B57, +BOOL_VEC3 : 0x8B58, +BOOL_VEC4 : 0x8B59, +FLOAT_MAT2 : 0x8B5A, +FLOAT_MAT3 : 0x8B5B, +FLOAT_MAT4 : 0x8B5C, +SAMPLER_2D : 0x8B5E, +SAMPLER_CUBE : 0x8B60, +VERTEX_ATTRIB_ARRAY_ENABLED : 0x8622, +VERTEX_ATTRIB_ARRAY_SIZE : 0x8623, +VERTEX_ATTRIB_ARRAY_STRIDE : 0x8624, +VERTEX_ATTRIB_ARRAY_TYPE : 0x8625, +VERTEX_ATTRIB_ARRAY_NORMALIZED : 0x886A, +VERTEX_ATTRIB_ARRAY_POINTER : 0x8645, +VERTEX_ATTRIB_ARRAY_BUFFER_BINDING : 0x889F, +//IMPLEMENTATION_COLOR_READ_TYPE : 0x8B9A, +//IMPLEMENTATION_COLOR_READ_FORMAT : 0x8B9B, +COMPILE_STATUS : 0x8B81, +//SHADER_COMPILER : 0x8DFA, +LOW_FLOAT : 0x8DF0, +MEDIUM_FLOAT : 0x8DF1, +HIGH_FLOAT : 0x8DF2, +LOW_INT : 0x8DF3, +MEDIUM_INT : 0x8DF4, +HIGH_INT : 0x8DF5, +FRAMEBUFFER : 0x8D40, +RENDERBUFFER : 0x8D41, +RGBA4 : 0x8056, +RGB5_A1 : 0x8057, +RGB565 : 0x8D62, +DEPTH_COMPONENT16 : 0x81A5, +STENCIL_INDEX8 : 0x8D48, +DEPTH_STENCIL : 0x84F9, +RENDERBUFFER_WIDTH : 0x8D42, +RENDERBUFFER_HEIGHT : 0x8D43, +RENDERBUFFER_INTERNAL_FORMAT : 0x8D44, +RENDERBUFFER_RED_SIZE : 0x8D50, +RENDERBUFFER_GREEN_SIZE : 0x8D51, +RENDERBUFFER_BLUE_SIZE : 0x8D52, +RENDERBUFFER_ALPHA_SIZE : 0x8D53, +RENDERBUFFER_DEPTH_SIZE : 0x8D54, +RENDERBUFFER_STENCIL_SIZE : 0x8D55, +FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE : 0x8CD0, +FRAMEBUFFER_ATTACHMENT_OBJECT_NAME : 0x8CD1, +FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL : 0x8CD2, +FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE : 0x8CD3, +COLOR_ATTACHMENT0 : 0x8CE0, +DEPTH_ATTACHMENT : 0x8D00, +STENCIL_ATTACHMENT : 0x8D20, +DEPTH_STENCIL_ATTACHMENT : 0x821A, +NONE : 0, +FRAMEBUFFER_COMPLETE : 0x8CD5, +FRAMEBUFFER_INCOMPLETE_ATTACHMENT : 0x8CD6, +FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT : 0x8CD7, +FRAMEBUFFER_INCOMPLETE_DIMENSIONS : 0x8CD9, +FRAMEBUFFER_UNSUPPORTED : 0x8CDD, +FRAMEBUFFER_BINDING : 0x8CA6, +RENDERBUFFER_BINDING : 0x8CA7, +MAX_RENDERBUFFER_SIZE : 0x84E8, +INVALID_FRAMEBUFFER_OPERATION : 0x0506, +//FALSE : 0, +//TRUE : 1, +UNPACK_FLIP_Y_WEBGL : 0x9240, +UNPACK_PREMULTIPLY_ALPHA_WEBGL : 0x9241 +} + +Tests.testOES20Constants = function(gl) { + for (var i in constants) { + assertProperty(gl, i) && + assertEquals(i, gl[i], constants[i]); + } + var extended = false; + for (var i in gl) { + if (i.match(/^[A-Z_]+$/) && constants[i] == null) { + if (!extended) { + extended = true; + var h = document.createElement('h3'); + h.textContent = "Also found the following extra constants"; + __testLog__.appendChild(h); + } + log(i); + } + } +} + +Tests.startUnit = function() { + var canvas = document.getElementById('gl'); + var gl = wrapGLContext(getGLContext(canvas)); + return [gl]; +} + +</script> +<style>canvas{ position:absolute; }</style> +</head><body> + <canvas id="gl" width="1" height="1"></canvas> +</body></html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/fuzzTheAPI.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/fuzzTheAPI.html new file mode 100644 index 0000000000..c1090aeb4b --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/fuzzTheAPI.html @@ -0,0 +1,116 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> + +<script type="application/javascript"> + +Tests.autorun = false; +Tests.message = "This will fuzz the API with random inputs for a [long] while." + + +function randomCall(testProgress, gl, m, arities) { + doTestNotify(m); + var argcs = {}; + var foundArity = false; + if (arities == null) { + testProgress.textContent += " 500 random arity calls on " + m + "\n"; + for (var i=0; i<50; i++) { + for (var j=0; j<10; j++) { + var args = generateRandomArgs(j); +// doTestNotify(m + ": " + args.toSource()); + try { + gl[m].apply(gl, args); + argcs[j] = true; + foundArity = true; + } catch (e) { + } + } + } + for (var j in argcs) { + testProgress.textContent += "200 arity " + j + " calls on " + m + "\n"; + for (var i=0; i<200; i++) { + var args = generateRandomArgs(j); +// doTestNotify(m + ": " + args.toSource()); + try { + gl[m].apply(gl, args); + argcs[j] = true; + } catch (e) { + } + } + } + } else { + for (var k=0; k<arities.length; k++) { + var j = arities[k]; + testProgress.textContent += "500 arity " + j + " calls on " + m + "\n"; + for (var i=0; i<500; i++) { + var args = generateRandomArgs(j); +// doTestNotify(m + ": " + args.toSource()); + try { + gl[m].apply(gl, args); + } catch (e) { + } + } + } + } +// doTestNotify(m+"--OK"); +} + +Tests.testGetGLWeb20 = function() { + var testProgress = document.getElementById('testProgress'); + var funcnames = document.getElementById('funcnames').value.split(","); + var canvas = document.getElementById('glweb20'); + var gl; + assertOk(function(){gl = getGLContext(canvas);}); + var funcs = []; + for (var i=0; i<funcnames.length; i++) { + var fn = funcnames[i]; + fn = fn.replace(/^\s+|\s+$/g, ''); + if (fn.length > 0) + funcs.push(fn); + } + if (funcs.length == 0) { + for (var m in gl) + try{if (typeof gl[m] == 'function') + funcs.push(m);}catch(e){} + } + var idx = 0; + var count = 0; + var limit = 1000; + var iv1; + var iv2; + iv1 = setInterval(function(){ + if (idx >= funcs.length) { + iv2 = setInterval(function(){ + if (count >= limit) { + clearInterval(iv2); + return false; + } + count++; + var f = Math.floor(Math.random() * funcs.length); + randomCall(testProgress, gl, funcs[f]); + }, 50); + clearInterval(iv1); + return false; + } + randomCall(testProgress, gl, funcs[idx]); + idx++; + }, 50); +} + +</script> +<style>canvas{ position:absolute; }</style> +</head><body> + <canvas id="glweb20" width="16" height="16"></canvas> + <p>Optional: Enter a comma-separated list of functions to fuzz (leave blank for full API)</p> + <input type="text" size="40" id="funcnames" value=""> + <pre id="testProgress"></pre> +</body></html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/getContext.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/getContext.html new file mode 100644 index 0000000000..14c0559123 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/getContext.html @@ -0,0 +1,38 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> + +<script type="application/javascript"> + +Tests.testGetWebGL = function() { + var canvas = document.getElementById('webgl'); + var gl; + assertOk(function(){gl = getGLContext(canvas)}); + assertEquals("ctx.canvas === canvas", gl.canvas, canvas); + assertOk(function(){g2d = canvas.getContext('2d')}); + assert("Should get a null 2d context after getting webgl context", g2d === null); +} + +Tests.testGet2D = function() { + var canvas = document.getElementById('2d'); + var g2d; + var gl; + assertOk(function(){g2d = canvas.getContext('2d')}); + assertOk(function(){gl = getGLContext(canvas)}); + assert("Should get a null WebGL context after getting 2D context", gl === null); +} +</script> +<style>canvas{position:absolute;}</style> +</head><body> + <canvas id="2d" width="1" height="1"></canvas> + <canvas id="webgl" width="1" height="1"></canvas> +</body></html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/methods.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/methods.html new file mode 100644 index 0000000000..d6d14bd827 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/methods.html @@ -0,0 +1,180 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> +<script type="application/javascript"> + +/* + The following tests are generated from + http://www.khronos.org/registry/gles/api/2.0/gl2.h + and api_modifications.txt +*/ +var methods = ['canvas', +"activeTexture", +"attachShader", +"bindAttribLocation", +"bindBuffer", +"bindFramebuffer", +"bindRenderbuffer", +"bindTexture", +"blendColor", +"blendEquation", +"blendEquationSeparate", +"blendFunc", +"blendFuncSeparate", +"bufferData", +"bufferSubData", +"checkFramebufferStatus", +"clear", +"clearColor", +"clearDepth", +"clearStencil", +"colorMask", +"compileShader", +"copyTexImage2D", +"copyTexSubImage2D", +"createProgram", +"createShader", +"cullFace", +"deleteBuffer", +"deleteFramebuffer", +"deleteProgram", +"deleteRenderbuffer", +"deleteShader", +"deleteTexture", +"depthFunc", +"depthMask", +"depthRange", +"detachShader", +"disable", +"disableVertexAttribArray", +"drawArrays", +"drawElements", +"enable", +"enableVertexAttribArray", +"finish", +"flush", +"framebufferRenderbuffer", +"framebufferTexture2D", +"frontFace", +"createBuffer", +"generateMipmap", +"createFramebuffer", +"createRenderbuffer", +"createTexture", +"getActiveAttrib", +"getActiveUniform", +"getAttachedShaders", +"getAttribLocation", +"getBufferParameter", +"getError", +"getExtension", +"getSupportedExtensions", +"getFramebufferAttachmentParameter", +"getProgramInfoLog", +"getRenderbufferParameter", +"getShaderInfoLog", +"getShaderSource", +"getUniformLocation", +"hint", +"isBuffer", +"isContextLost", +"isEnabled", +"isFramebuffer", +"isProgram", +"isRenderbuffer", +"isShader", +"isTexture", +"lineWidth", +"linkProgram", +"polygonOffset", +"readPixels", +"renderbufferStorage", +"sampleCoverage", +"scissor", +"shaderSource", +"stencilFunc", +"stencilFuncSeparate", +"stencilMask", +"stencilMaskSeparate", +"stencilOp", +"stencilOpSeparate", +"texImage2D", +"texParameteri", +"texSubImage2D", +"uniform1f", +"uniform1fv", +"uniform1i", +"uniform1iv", +"uniform2f", +"uniform2fv", +"uniform2i", +"uniform2iv", +"uniform3f", +"uniform3fv", +"uniform3i", +"uniform3iv", +"uniform4f", +"uniform4fv", +"uniform4i", +"uniform4iv", +"uniformMatrix2fv", +"uniformMatrix3fv", +"uniformMatrix4fv", +"useProgram", +"validateProgram", +"vertexAttrib1f", +"vertexAttrib1fv", +"vertexAttrib2f", +"vertexAttrib2fv", +"vertexAttrib3f", +"vertexAttrib3fv", +"vertexAttrib4f", +"vertexAttrib4fv", +"vertexAttribPointer", +"viewport", +"getParameter", +"getProgramParameter", +"getShaderParameter", +"getTexParameter", +"getUniform", +"getVertexAttrib" +] + +Tests.testOES20Methods = function(gl) { + for (var i=0; i<methods.length; i++) { + assertProperty(gl, methods[i]); + } + var extended = false; + for (var i in gl) { + if (i.match(/^[a-z_]+$/) && methods.indexOf(i) == -1) { + if (!extended) { + extended = true; + var h = document.createElement('h3'); + h.textContent = "Also found the following extra properties"; + __testLog__.appendChild(h); + } + log(i); + } + } +} + +Tests.startUnit = function() { + var canvas = document.getElementById('gl'); + var gl = wrapGLContext(getGLContext(canvas)); + return [gl]; +} + +</script> +<style>canvas{ position:absolute; }</style> +</head><body> + <canvas id="gl" width="1" height="1"></canvas> +</body></html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-A.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-A.html new file mode 100644 index 0000000000..fe453457c3 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-A.html @@ -0,0 +1,63 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> +<script type="application/javascript" src="quickCheckAPI.js"></script> +<script type="application/javascript" src="argGenerators-A.js"></script> + +<script type="application/javascript"> + +// Test that all GL functions specified in ArgGenerators work +// when called with randomly generated valid arguments +Tests.testValidArgs = function() { + var randomTestCount = 100; + for (var name in ArgGenerators) { + try { + if (!GL[name]) + throw (new Error(name + " is missing from the WebGL context")); + var argGen = ArgGenerators[name]; + var alreadyTriedArgs = {}; + if (!argGen.generate) continue; + // test each GL function with randomTestCount randomly generated valid args + argGeneratorTestRunner(argGen, function(args, gen, setupVars) { + if (!gen.noAlreadyTriedCheck) { + var src = Object.toSource(args); + if (alreadyTriedArgs[src]) + return true; + + alreadyTriedArgs[src] = true; + } + var ok = false; + // if we have an validity checker, assert that the generated args are valid + if (gen.checkArgValidity) + assert("Valid args: "+name+"("+argsToString(args)+")", + gen.checkArgValidity.apply(gen, args)); + var rv; + // assert that GL function works when called with valid args + assertOk("This should work: "+name+"("+argsToString(args)+")", + function(){rv = GL[name].apply(GL, args); ok = true;}); + // if we need to cleanup the return value, do it here + // e.g. calling gl.deleteBuffer(rv) after testing gl.createBuffer() above + if (gen.returnValueCleanup) + assertOk("Cleaning up return value after "+name+"("+argsToString(args)+")", + function() { gen.returnValueCleanup(rv); }); + return ok; + }, argGen.testCount || randomTestCount); + } catch(e) { + testFailed(name, e.name, formatError(e)); + } + } +} + +</script> +<style>canvas{position:absolute;}</style> +</head><body> +</body></html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-B1.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-B1.html new file mode 100644 index 0000000000..6d34f27795 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-B1.html @@ -0,0 +1,63 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> +<script type="application/javascript" src="quickCheckAPI.js"></script> +<script type="application/javascript" src="argGenerators-B1.js"></script> + +<script type="application/javascript"> + +// Test that all GL functions specified in ArgGenerators work +// when called with randomly generated valid arguments +Tests.testValidArgs = function() { + var randomTestCount = 100; + for (var name in ArgGenerators) { + try { + if (!GL[name]) + throw (new Error(name + " is missing from the WebGL context")); + var argGen = ArgGenerators[name]; + var alreadyTriedArgs = {}; + if (!argGen.generate) continue; + // test each GL function with randomTestCount randomly generated valid args + argGeneratorTestRunner(argGen, function(args, gen, setupVars) { + if (!gen.noAlreadyTriedCheck) { + var src = Object.toSource(args); + if (alreadyTriedArgs[src]) + return true; + + alreadyTriedArgs[src] = true; + } + var ok = false; + // if we have an validity checker, assert that the generated args are valid + if (gen.checkArgValidity) + assert("Valid args: "+name+"("+argsToString(args)+")", + gen.checkArgValidity.apply(gen, args)); + var rv; + // assert that GL function works when called with valid args + assertOk("This should work: "+name+"("+argsToString(args)+")", + function(){rv = GL[name].apply(GL, args); ok = true;}); + // if we need to cleanup the return value, do it here + // e.g. calling gl.deleteBuffer(rv) after testing gl.createBuffer() above + if (gen.returnValueCleanup) + assertOk("Cleaning up return value after "+name+"("+argsToString(args)+")", + function() { gen.returnValueCleanup(rv); }); + return ok; + }, argGen.testCount || randomTestCount); + } catch(e) { + testFailed(name, e.name, formatError(e)); + } + } +} + +</script> +<style>canvas{position:absolute;}</style> +</head><body> +</body></html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-B2.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-B2.html new file mode 100644 index 0000000000..2a1ddd9bd9 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-B2.html @@ -0,0 +1,63 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> +<script type="application/javascript" src="quickCheckAPI.js"></script> +<script type="application/javascript" src="argGenerators-B2.js"></script> + +<script type="application/javascript"> + +// Test that all GL functions specified in ArgGenerators work +// when called with randomly generated valid arguments +Tests.testValidArgs = function() { + var randomTestCount = 100; + for (var name in ArgGenerators) { + try { + if (!GL[name]) + throw (new Error(name + " is missing from the WebGL context")); + var argGen = ArgGenerators[name]; + var alreadyTriedArgs = {}; + if (!argGen.generate) continue; + // test each GL function with randomTestCount randomly generated valid args + argGeneratorTestRunner(argGen, function(args, gen, setupVars) { + if (!gen.noAlreadyTriedCheck) { + var src = Object.toSource(args); + if (alreadyTriedArgs[src]) + return true; + + alreadyTriedArgs[src] = true; + } + var ok = false; + // if we have an validity checker, assert that the generated args are valid + if (gen.checkArgValidity) + assert("Valid args: "+name+"("+argsToString(args)+")", + gen.checkArgValidity.apply(gen, args)); + var rv; + // assert that GL function works when called with valid args + assertOk("This should work: "+name+"("+argsToString(args)+")", + function(){rv = GL[name].apply(GL, args); ok = true;}); + // if we need to cleanup the return value, do it here + // e.g. calling gl.deleteBuffer(rv) after testing gl.createBuffer() above + if (gen.returnValueCleanup) + assertOk("Cleaning up return value after "+name+"("+argsToString(args)+")", + function() { gen.returnValueCleanup(rv); }); + return ok; + }, argGen.testCount || randomTestCount); + } catch(e) { + testFailed(name, e.name, formatError(e)); + } + } +} + +</script> +<style>canvas{position:absolute;}</style> +</head><body> +</body></html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-B3.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-B3.html new file mode 100644 index 0000000000..08e85dbc04 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-B3.html @@ -0,0 +1,63 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> +<script type="application/javascript" src="quickCheckAPI.js"></script> +<script type="application/javascript" src="argGenerators-B3.js"></script> + +<script type="application/javascript"> + +// Test that all GL functions specified in ArgGenerators work +// when called with randomly generated valid arguments +Tests.testValidArgs = function() { + var randomTestCount = 100; + for (var name in ArgGenerators) { + try { + if (!GL[name]) + throw (new Error(name + " is missing from the WebGL context")); + var argGen = ArgGenerators[name]; + var alreadyTriedArgs = {}; + if (!argGen.generate) continue; + // test each GL function with randomTestCount randomly generated valid args + argGeneratorTestRunner(argGen, function(args, gen, setupVars) { + if (!gen.noAlreadyTriedCheck) { + var src = Object.toSource(args); + if (alreadyTriedArgs[src]) + return true; + + alreadyTriedArgs[src] = true; + } + var ok = false; + // if we have an validity checker, assert that the generated args are valid + if (gen.checkArgValidity) + assert("Valid args: "+name+"("+argsToString(args)+")", + gen.checkArgValidity.apply(gen, args)); + var rv; + // assert that GL function works when called with valid args + assertOk("This should work: "+name+"("+argsToString(args)+")", + function(){rv = GL[name].apply(GL, args); ok = true;}); + // if we need to cleanup the return value, do it here + // e.g. calling gl.deleteBuffer(rv) after testing gl.createBuffer() above + if (gen.returnValueCleanup) + assertOk("Cleaning up return value after "+name+"("+argsToString(args)+")", + function() { gen.returnValueCleanup(rv); }); + return ok; + }, argGen.testCount || randomTestCount); + } catch(e) { + testFailed(name, e.name, formatError(e)); + } + } +} + +</script> +<style>canvas{position:absolute;}</style> +</head><body> +</body></html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-B4.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-B4.html new file mode 100644 index 0000000000..9ee5228e78 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-B4.html @@ -0,0 +1,63 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> +<script type="application/javascript" src="quickCheckAPI.js"></script> +<script type="application/javascript" src="argGenerators-B4.js"></script> + +<script type="application/javascript"> + +// Test that all GL functions specified in ArgGenerators work +// when called with randomly generated valid arguments +Tests.testValidArgs = function() { + var randomTestCount = 100; + for (var name in ArgGenerators) { + try { + if (!GL[name]) + throw (new Error(name + " is missing from the WebGL context")); + var argGen = ArgGenerators[name]; + var alreadyTriedArgs = {}; + if (!argGen.generate) continue; + // test each GL function with randomTestCount randomly generated valid args + argGeneratorTestRunner(argGen, function(args, gen, setupVars) { + if (!gen.noAlreadyTriedCheck) { + var src = Object.toSource(args); + if (alreadyTriedArgs[src]) + return true; + + alreadyTriedArgs[src] = true; + } + var ok = false; + // if we have an validity checker, assert that the generated args are valid + if (gen.checkArgValidity) + assert("Valid args: "+name+"("+argsToString(args)+")", + gen.checkArgValidity.apply(gen, args)); + var rv; + // assert that GL function works when called with valid args + assertOk("This should work: "+name+"("+argsToString(args)+")", + function(){rv = GL[name].apply(GL, args); ok = true;}); + // if we need to cleanup the return value, do it here + // e.g. calling gl.deleteBuffer(rv) after testing gl.createBuffer() above + if (gen.returnValueCleanup) + assertOk("Cleaning up return value after "+name+"("+argsToString(args)+")", + function() { gen.returnValueCleanup(rv); }); + return ok; + }, argGen.testCount || randomTestCount); + } catch(e) { + testFailed(name, e.name, formatError(e)); + } + } +} + +</script> +<style>canvas{position:absolute;}</style> +</head><body> +</body></html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-C.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-C.html new file mode 100644 index 0000000000..3717e41e77 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-C.html @@ -0,0 +1,63 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> +<script type="application/javascript" src="quickCheckAPI.js"></script> +<script type="application/javascript" src="argGenerators-C.js"></script> + +<script type="application/javascript"> + +// Test that all GL functions specified in ArgGenerators work +// when called with randomly generated valid arguments +Tests.testValidArgs = function() { + var randomTestCount = 100; + for (var name in ArgGenerators) { + try { + if (!GL[name]) + throw (new Error(name + " is missing from the WebGL context")); + var argGen = ArgGenerators[name]; + var alreadyTriedArgs = {}; + if (!argGen.generate) continue; + // test each GL function with randomTestCount randomly generated valid args + argGeneratorTestRunner(argGen, function(args, gen, setupVars) { + if (!gen.noAlreadyTriedCheck) { + var src = Object.toSource(args); + if (alreadyTriedArgs[src]) + return true; + + alreadyTriedArgs[src] = true; + } + var ok = false; + // if we have an validity checker, assert that the generated args are valid + if (gen.checkArgValidity) + assert("Valid args: "+name+"("+argsToString(args)+")", + gen.checkArgValidity.apply(gen, args)); + var rv; + // assert that GL function works when called with valid args + assertOk("This should work: "+name+"("+argsToString(args)+")", + function(){rv = GL[name].apply(GL, args); ok = true;}); + // if we need to cleanup the return value, do it here + // e.g. calling gl.deleteBuffer(rv) after testing gl.createBuffer() above + if (gen.returnValueCleanup) + assertOk("Cleaning up return value after "+name+"("+argsToString(args)+")", + function() { gen.returnValueCleanup(rv); }); + return ok; + }, argGen.testCount || randomTestCount); + } catch(e) { + testFailed(name, e.name, formatError(e)); + } + } +} + +</script> +<style>canvas{position:absolute;}</style> +</head><body> +</body></html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-D_G.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-D_G.html new file mode 100644 index 0000000000..c692db331b --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-D_G.html @@ -0,0 +1,63 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> +<script type="application/javascript" src="quickCheckAPI.js"></script> +<script type="application/javascript" src="argGenerators-D_G.js"></script> + +<script type="application/javascript"> + +// Test that all GL functions specified in ArgGenerators work +// when called with randomly generated valid arguments +Tests.testValidArgs = function() { + var randomTestCount = 100; + for (var name in ArgGenerators) { + try { + if (!GL[name]) + throw (new Error(name + " is missing from the WebGL context")); + var argGen = ArgGenerators[name]; + var alreadyTriedArgs = {}; + if (!argGen.generate) continue; + // test each GL function with randomTestCount randomly generated valid args + argGeneratorTestRunner(argGen, function(args, gen, setupVars) { + if (!gen.noAlreadyTriedCheck) { + var src = Object.toSource(args); + if (alreadyTriedArgs[src]) + return true; + + alreadyTriedArgs[src] = true; + } + var ok = false; + // if we have an validity checker, assert that the generated args are valid + if (gen.checkArgValidity) + assert("Valid args: "+name+"("+argsToString(args)+")", + gen.checkArgValidity.apply(gen, args)); + var rv; + // assert that GL function works when called with valid args + assertOk("This should work: "+name+"("+argsToString(args)+")", + function(){rv = GL[name].apply(GL, args); ok = true;}); + // if we need to cleanup the return value, do it here + // e.g. calling gl.deleteBuffer(rv) after testing gl.createBuffer() above + if (gen.returnValueCleanup) + assertOk("Cleaning up return value after "+name+"("+argsToString(args)+")", + function() { gen.returnValueCleanup(rv); }); + return ok; + }, argGen.testCount || randomTestCount); + } catch(e) { + testFailed(name, e.name, formatError(e)); + } + } +} + +</script> +<style>canvas{position:absolute;}</style> +</head><body> +</body></html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-G_I.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-G_I.html new file mode 100644 index 0000000000..1f474892fb --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-G_I.html @@ -0,0 +1,63 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> +<script type="application/javascript" src="quickCheckAPI.js"></script> +<script type="application/javascript" src="argGenerators-G_I.js"></script> + +<script type="application/javascript"> + +// Test that all GL functions specified in ArgGenerators work +// when called with randomly generated valid arguments +Tests.testValidArgs = function() { + var randomTestCount = 100; + for (var name in ArgGenerators) { + try { + if (!GL[name]) + throw (new Error(name + " is missing from the WebGL context")); + var argGen = ArgGenerators[name]; + var alreadyTriedArgs = {}; + if (!argGen.generate) continue; + // test each GL function with randomTestCount randomly generated valid args + argGeneratorTestRunner(argGen, function(args, gen, setupVars) { + if (!gen.noAlreadyTriedCheck) { + var src = Object.toSource(args); + if (alreadyTriedArgs[src]) + return true; + + alreadyTriedArgs[src] = true; + } + var ok = false; + // if we have an validity checker, assert that the generated args are valid + if (gen.checkArgValidity) + assert("Valid args: "+name+"("+argsToString(args)+")", + gen.checkArgValidity.apply(gen, args)); + var rv; + // assert that GL function works when called with valid args + assertOk("This should work: "+name+"("+argsToString(args)+")", + function(){rv = GL[name].apply(GL, args); ok = true;}); + // if we need to cleanup the return value, do it here + // e.g. calling gl.deleteBuffer(rv) after testing gl.createBuffer() above + if (gen.returnValueCleanup) + assertOk("Cleaning up return value after "+name+"("+argsToString(args)+")", + function() { gen.returnValueCleanup(rv); }); + return ok; + }, argGen.testCount || randomTestCount); + } catch(e) { + testFailed(name, e.name, formatError(e)); + } + } +} + +</script> +<style>canvas{position:absolute;}</style> +</head><body> +</body></html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-L_S.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-L_S.html new file mode 100644 index 0000000000..698e1c93d9 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-L_S.html @@ -0,0 +1,63 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> +<script type="application/javascript" src="quickCheckAPI.js"></script> +<script type="application/javascript" src="argGenerators-L_S.js"></script> + +<script type="application/javascript"> + +// Test that all GL functions specified in ArgGenerators work +// when called with randomly generated valid arguments +Tests.testValidArgs = function() { + var randomTestCount = 100; + for (var name in ArgGenerators) { + try { + if (!GL[name]) + throw (new Error(name + " is missing from the WebGL context")); + var argGen = ArgGenerators[name]; + var alreadyTriedArgs = {}; + if (!argGen.generate) continue; + // test each GL function with randomTestCount randomly generated valid args + argGeneratorTestRunner(argGen, function(args, gen, setupVars) { + if (!gen.noAlreadyTriedCheck) { + var src = Object.toSource(args); + if (alreadyTriedArgs[src]) + return true; + + alreadyTriedArgs[src] = true; + } + var ok = false; + // if we have an validity checker, assert that the generated args are valid + if (gen.checkArgValidity) + assert("Valid args: "+name+"("+argsToString(args)+")", + gen.checkArgValidity.apply(gen, args)); + var rv; + // assert that GL function works when called with valid args + assertOk("This should work: "+name+"("+argsToString(args)+")", + function(){rv = GL[name].apply(GL, args); ok = true;}); + // if we need to cleanup the return value, do it here + // e.g. calling gl.deleteBuffer(rv) after testing gl.createBuffer() above + if (gen.returnValueCleanup) + assertOk("Cleaning up return value after "+name+"("+argsToString(args)+")", + function() { gen.returnValueCleanup(rv); }); + return ok; + }, argGen.testCount || randomTestCount); + } catch(e) { + testFailed(name, e.name, formatError(e)); + } + } +} + +</script> +<style>canvas{position:absolute;}</style> +</head><body> +</body></html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-S_V.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-S_V.html new file mode 100644 index 0000000000..84e60151e1 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI-S_V.html @@ -0,0 +1,63 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> +<script type="application/javascript" src="quickCheckAPI.js"></script> +<script type="application/javascript" src="argGenerators-S_V.js"></script> + +<script type="application/javascript"> + +// Test that all GL functions specified in ArgGenerators work +// when called with randomly generated valid arguments +Tests.testValidArgs = function() { + var randomTestCount = 100; + for (var name in ArgGenerators) { + try { + if (!GL[name]) + throw (new Error(name + " is missing from the WebGL context")); + var argGen = ArgGenerators[name]; + var alreadyTriedArgs = {}; + if (!argGen.generate) continue; + // test each GL function with randomTestCount randomly generated valid args + argGeneratorTestRunner(argGen, function(args, gen, setupVars) { + if (!gen.noAlreadyTriedCheck) { + var src = Object.toSource(args); + if (alreadyTriedArgs[src]) + return true; + + alreadyTriedArgs[src] = true; + } + var ok = false; + // if we have an validity checker, assert that the generated args are valid + if (gen.checkArgValidity) + assert("Valid args: "+name+"("+argsToString(args)+")", + gen.checkArgValidity.apply(gen, args)); + var rv; + // assert that GL function works when called with valid args + assertOk("This should work: "+name+"("+argsToString(args)+")", + function(){rv = GL[name].apply(GL, args); ok = true;}); + // if we need to cleanup the return value, do it here + // e.g. calling gl.deleteBuffer(rv) after testing gl.createBuffer() above + if (gen.returnValueCleanup) + assertOk("Cleaning up return value after "+name+"("+argsToString(args)+")", + function() { gen.returnValueCleanup(rv); }); + return ok; + }, argGen.testCount || randomTestCount); + } catch(e) { + testFailed(name, e.name, formatError(e)); + } + } +} + +</script> +<style>canvas{position:absolute;}</style> +</head><body> +</body></html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI.js b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI.js new file mode 100644 index 0000000000..50e74963e2 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPI.js @@ -0,0 +1,414 @@ +/* +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +*/ + +/* + QuickCheck tests for WebGL: + + 1. Write a valid arg generator for each function + 1.1. Write valid arg predicates to use with random generator: + if value passes generator, accept it as valid. + 1.2. Often needs initializing and cleanup: + setup - generate - cleanup + gl.createBuffer - test(bindBufferGenerator) - gl.deleteBuffer + + 2. Write an invalid arg generator + 2.1. Take valid args, modify an arg until the args no longer pass + checkArgValidity. + 2.2. Repeat for all args. + + 3. Test functions using the generators + 3.1. Args generated with the valid arg generator should pass + assertOk(f(args)) + 3.2. Args generated with the invalid arg generator should pass + assertFail(f(args)) +*/ +var GLcanvas = document.createElement('canvas'); +var canvas2D = document.createElement('canvas'); +GLcanvas.width = GLcanvas.height = 256; +GL = getGLContext(GLcanvas); +Array.from = function(o) { + var a = []; + for (var i=0; i<o.length; i++) + a.push(o[i]); + return a; +} +Array.prototype.has = function(v) { return this.indexOf(v) != -1; } +Array.prototype.random = function() { return this[randomInt(this.length)]; } + +castToInt = function(o) { + if (typeof o == 'number') + return isNaN(o) ? 0 : Math.floor(o); + if (o == true) return 1; + return 0; +}; + +// Creates a constant checker / generator from its arguments. +// +// E.g. if you want a constant checker for the constants 1, 2, and 3, you +// would do the following: +// +// var cc = constCheck(1,2,3); +// var randomConst = cc.random(); +// if (cc.has(randomConst)) +// console.log("randomConst is included in cc's constants"); +// +constCheck = function() { + var a = Array.from(arguments); + a.has = function(v) { return this.indexOf(castToInt(v)) != -1; }; + return a; +} + +bindTextureTarget = constCheck(GL.TEXTURE_2D, GL.TEXTURE_CUBE_MAP); +blendEquationMode = constCheck(GL.FUNC_ADD, GL.FUNC_SUBTRACT, GL.FUNC_REVERSE_SUBTRACT); +blendFuncSfactor = constCheck( + GL.ZERO, GL.ONE, GL.SRC_COLOR, GL.ONE_MINUS_SRC_COLOR, GL.DST_COLOR, + GL.ONE_MINUS_DST_COLOR, GL.SRC_ALPHA, GL.ONE_MINUS_SRC_ALPHA, GL.DST_ALPHA, + GL.ONE_MINUS_DST_ALPHA, GL.CONSTANT_COLOR, GL.ONE_MINUS_CONSTANT_COLOR, + GL.CONSTANT_ALPHA, GL.ONE_MINUS_CONSTANT_ALPHA, GL.SRC_ALPHA_SATURATE +); +blendFuncDfactor = constCheck( + GL.ZERO, GL.ONE, GL.SRC_COLOR, GL.ONE_MINUS_SRC_COLOR, GL.DST_COLOR, + GL.ONE_MINUS_DST_COLOR, GL.SRC_ALPHA, GL.ONE_MINUS_SRC_ALPHA, GL.DST_ALPHA, + GL.ONE_MINUS_DST_ALPHA, GL.CONSTANT_COLOR, GL.ONE_MINUS_CONSTANT_COLOR, + GL.CONSTANT_ALPHA, GL.ONE_MINUS_CONSTANT_ALPHA +); +bufferTarget = constCheck(GL.ARRAY_BUFFER, GL.ELEMENT_ARRAY_BUFFER); +bufferMode = constCheck(GL.STREAM_DRAW, GL.STATIC_DRAW, GL.DYNAMIC_DRAW); +clearMask = constCheck( + GL.COLOR_BUFFER_BIT | GL.DEPTH_BUFFER_BIT | GL.STENCIL_BUFFER_BIT, + GL.COLOR_BUFFER_BIT | GL.DEPTH_BUFFER_BIT, + GL.COLOR_BUFFER_BIT | GL.STENCIL_BUFFER_BIT, + GL.DEPTH_BUFFER_BIT | GL.STENCIL_BUFFER_BIT, + GL.COLOR_BUFFER_BIT, GL.DEPTH_BUFFER_BIT, GL.STENCIL_BUFFER_BIT, 0 +); +cullFace = constCheck(GL.FRONT, GL.BACK, GL.FRONT_AND_BACK); +depthFuncFunc = constCheck( + GL.NEVER, GL.LESS, GL.EQUAL, GL.LEQUAL, GL.GREATER, GL.NOTEQUAL, + GL.GEQUAL, GL.ALWAYS +); +stencilFuncFunc = depthFuncFunc; +enableCap = constCheck( + GL.BLEND, GL.CULL_FACE, GL.DEPTH_TEST, GL.DITHER, GL.POLYGON_OFFSET_FILL, + GL.SAMPLE_ALPHA_TO_COVERAGE, GL.SAMPLE_COVERAGE, GL.SCISSOR_TEST, + GL.STENCIL_TEST +); +frontFaceMode = constCheck(GL.CCW, GL.CW); +getParameterPname = constCheck( + GL.ACTIVE_TEXTURE || "GL.ACTIVE_TEXTURE", + GL.ALIASED_LINE_WIDTH_RANGE || "GL.ALIASED_LINE_WIDTH_RANGE", + GL.ALIASED_POINT_SIZE_RANGE || "GL.ALIASED_POINT_SIZE_RANGE", + GL.ALPHA_BITS || "GL.ALPHA_BITS", + GL.ARRAY_BUFFER_BINDING || "GL.ARRAY_BUFFER_BINDING", + GL.BLEND || "GL.BLEND", + GL.BLEND_COLOR || "GL.BLEND_COLOR", + GL.BLEND_DST_ALPHA || "GL.BLEND_DST_ALPHA", + GL.BLEND_DST_RGB || "GL.BLEND_DST_RGB", + GL.BLEND_EQUATION_ALPHA || "GL.BLEND_EQUATION_ALPHA", + GL.BLEND_EQUATION_RGB || "GL.BLEND_EQUATION_RGB", + GL.BLEND_SRC_ALPHA || "GL.BLEND_SRC_ALPHA", + GL.BLEND_SRC_RGB || "GL.BLEND_SRC_RGB", + GL.BLUE_BITS || "GL.BLUE_BITS", + GL.COLOR_CLEAR_VALUE || "GL.COLOR_CLEAR_VALUE", + GL.COLOR_WRITEMASK || "GL.COLOR_WRITEMASK", + GL.COMPRESSED_TEXTURE_FORMATS || "GL.COMPRESSED_TEXTURE_FORMATS", + GL.CULL_FACE || "GL.CULL_FACE", + GL.CULL_FACE_MODE || "GL.CULL_FACE_MODE", + GL.CURRENT_PROGRAM || "GL.CURRENT_PROGRAM", + GL.DEPTH_BITS || "GL.DEPTH_BITS", + GL.DEPTH_CLEAR_VALUE || "GL.DEPTH_CLEAR_VALUE", + GL.DEPTH_FUNC || "GL.DEPTH_FUNC", + GL.DEPTH_RANGE || "GL.DEPTH_RANGE", + GL.DEPTH_TEST || "GL.DEPTH_TEST", + GL.DEPTH_WRITEMASK || "GL.DEPTH_WRITEMASK", + GL.DITHER || "GL.DITHER", + GL.ELEMENT_ARRAY_BUFFER_BINDING || "GL.ELEMENT_ARRAY_BUFFER_BINDING", + GL.FRAMEBUFFER_BINDING || "GL.FRAMEBUFFER_BINDING", + GL.FRONT_FACE || "GL.FRONT_FACE", + GL.GENERATE_MIPMAP_HINT || "GL.GENERATE_MIPMAP_HINT", + GL.GREEN_BITS || "GL.GREEN_BITS", + GL.LINE_WIDTH || "GL.LINE_WIDTH", + GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS || "GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS", + GL.MAX_CUBE_MAP_TEXTURE_SIZE || "GL.MAX_CUBE_MAP_TEXTURE_SIZE", + GL.MAX_FRAGMENT_UNIFORM_VECTORS || "GL.MAX_FRAGMENT_UNIFORM_VECTORS", + GL.MAX_RENDERBUFFER_SIZE || "GL.MAX_RENDERBUFFER_SIZE", + GL.MAX_TEXTURE_IMAGE_UNITS || "GL.MAX_TEXTURE_IMAGE_UNITS", + GL.MAX_TEXTURE_SIZE || "GL.MAX_TEXTURE_SIZE", + GL.MAX_VARYING_VECTORS || "GL.MAX_VARYING_VECTORS", + GL.MAX_VERTEX_ATTRIBS || "GL.MAX_VERTEX_ATTRIBS", + GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS || "GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS", + GL.MAX_VERTEX_UNIFORM_VECTORS || "GL.MAX_VERTEX_UNIFORM_VECTORS", + GL.MAX_VIEWPORT_DIMS || "GL.MAX_VIEWPORT_DIMS", + GL.PACK_ALIGNMENT || "GL.PACK_ALIGNMENT", + GL.POLYGON_OFFSET_FACTOR || "GL.POLYGON_OFFSET_FACTOR", + GL.POLYGON_OFFSET_FILL || "GL.POLYGON_OFFSET_FILL", + GL.POLYGON_OFFSET_UNITS || "GL.POLYGON_OFFSET_UNITS", + GL.RED_BITS || "GL.RED_BITS", + GL.RENDERBUFFER_BINDING || "GL.RENDERBUFFER_BINDING", + GL.SAMPLE_BUFFERS || "GL.SAMPLE_BUFFERS", + GL.SAMPLE_COVERAGE_INVERT || "GL.SAMPLE_COVERAGE_INVERT", + GL.SAMPLE_COVERAGE_VALUE || "GL.SAMPLE_COVERAGE_VALUE", + GL.SAMPLES || "GL.SAMPLES", + GL.SCISSOR_BOX || "GL.SCISSOR_BOX", + GL.SCISSOR_TEST || "GL.SCISSOR_TEST", + GL.STENCIL_BACK_FAIL || "GL.STENCIL_BACK_FAIL", + GL.STENCIL_BACK_FUNC || "GL.STENCIL_BACK_FUNC", + GL.STENCIL_BACK_PASS_DEPTH_FAIL || "GL.STENCIL_BACK_PASS_DEPTH_FAIL", + GL.STENCIL_BACK_PASS_DEPTH_PASS || "GL.STENCIL_BACK_PASS_DEPTH_PASS", + GL.STENCIL_BACK_REF || "GL.STENCIL_BACK_REF", + GL.STENCIL_BACK_VALUE_MASK || "GL.STENCIL_BACK_VALUE_MASK", + GL.STENCIL_BACK_WRITEMASK || "GL.STENCIL_BACK_WRITEMASK", + GL.STENCIL_BITS || "GL.STENCIL_BITS", + GL.STENCIL_CLEAR_VALUE || "GL.STENCIL_CLEAR_VALUE", + GL.STENCIL_FAIL || "GL.STENCIL_FAIL", + GL.STENCIL_FUNC || "GL.STENCIL_FUNC", + GL.STENCIL_PASS_DEPTH_FAIL || "GL.STENCIL_PASS_DEPTH_FAIL", + GL.STENCIL_PASS_DEPTH_PASS || "GL.STENCIL_PASS_DEPTH_PASS", + GL.STENCIL_REF || "GL.STENCIL_REF", + GL.STENCIL_TEST || "GL.STENCIL_TEST", + GL.STENCIL_VALUE_MASK || "GL.STENCIL_VALUE_MASK", + GL.STENCIL_WRITEMASK || "GL.STENCIL_WRITEMASK", + GL.SUBPIXEL_BITS || "GL.SUBPIXEL_BITS", + GL.TEXTURE_BINDING_2D || "GL.TEXTURE_BINDING_2D", + GL.TEXTURE_BINDING_CUBE_MAP || "GL.TEXTURE_BINDING_CUBE_MAP", + GL.UNPACK_ALIGNMENT || "GL.UNPACK_ALIGNMENT", + GL.VIEWPORT || "GL.VIEWPORT" +); +mipmapHint = constCheck(GL.FASTEST, GL.NICEST, GL.DONT_CARE); +pixelStoreiPname = constCheck(GL.PACK_ALIGNMENT, GL.UNPACK_ALIGNMENT); +pixelStoreiParam = constCheck(1,2,4,8); +shaderType = constCheck(GL.VERTEX_SHADER, GL.FRAGMENT_SHADER); +stencilOp = constCheck(GL.KEEP, GL.ZERO, GL.REPLACE, GL.INCR, GL.INCR_WRAP, + GL.DECR, GL.DECR_WRAP, GL.INVERT); +texImageTarget = constCheck( + GL.TEXTURE_2D, + GL.TEXTURE_CUBE_MAP_POSITIVE_X, + GL.TEXTURE_CUBE_MAP_NEGATIVE_X, + GL.TEXTURE_CUBE_MAP_POSITIVE_Y, + GL.TEXTURE_CUBE_MAP_NEGATIVE_Y, + GL.TEXTURE_CUBE_MAP_POSITIVE_Z, + GL.TEXTURE_CUBE_MAP_NEGATIVE_Z +); +texImageInternalFormat = constCheck( + GL.ALPHA, + GL.LUMINANCE, + GL.LUMINANCE_ALPHA, + GL.RGB, + GL.RGBA +); +texImageFormat = constCheck( + GL.ALPHA, + GL.LUMINANCE, + GL.LUMINANCE_ALPHA, + GL.RGB, + GL.RGBA +); +texImageType = constCheck(GL.UNSIGNED_BYTE); +texParameterPname = constCheck( + GL.TEXTURE_MIN_FILTER, GL.TEXTURE_MAG_FILTER, + GL.TEXTURE_WRAP_S, GL.TEXTURE_WRAP_T); +texParameterParam = {}; +texParameterParam[GL.TEXTURE_MIN_FILTER] = constCheck( + GL.NEAREST, GL.LINEAR, GL.NEAREST_MIPMAP_NEAREST, GL.LINEAR_MIPMAP_NEAREST, + GL.NEAREST_MIPMAP_LINEAR, GL.LINEAR_MIPMAP_LINEAR); +texParameterParam[GL.TEXTURE_MAG_FILTER] = constCheck(GL.NEAREST, GL.LINEAR); +texParameterParam[GL.TEXTURE_WRAP_S] = constCheck( + GL.CLAMP_TO_EDGE, GL.MIRRORED_REPEAT, GL.REPEAT); +texParameterParam[GL.TEXTURE_WRAP_T] = texParameterParam[GL.TEXTURE_WRAP_S]; +textureUnit = constCheck.apply(this, (function(){ + var textureUnits = []; + var texUnits = GL.getParameter(GL.MAX_TEXTURE_IMAGE_UNITS); + for (var i=0; i<texUnits; i++) textureUnits.push(GL['TEXTURE'+i]); + return textureUnits; +})()); + +var StencilBits = GL.getParameter(GL.STENCIL_BITS); +var MaxStencilValue = 1 << StencilBits; + +var MaxVertexAttribs = GL.getParameter(GL.MAX_VERTEX_ATTRIBS); +var LineWidthRange = GL.getParameter(GL.ALIASED_LINE_WIDTH_RANGE); + +// Returns true if bufData can be passed to GL.bufferData +isBufferData = function(bufData) { + if (typeof bufData == 'number') + return bufData >= 0; + if (bufData instanceof ArrayBuffer) + return true; + return WebGLArrayTypes.some(function(t) { + return bufData instanceof t; + }); +}; + +isVertexAttribute = function(idx) { + if (typeof idx != 'number') return false; + return idx >= 0 && idx < MaxVertexAttribs; +}; + +isValidName = function(name) { + if (typeof name != 'string') return false; + for (var i=0; i<name.length; i++) { + var c = name.charCodeAt(i); + if (c & 0x00FF == 0 || c & 0xFF00 == 0) { + return false; + } + } + return true; +}; + +WebGLArrayTypes = [ + Float32Array, + Int32Array, + Int16Array, + Int8Array, + Uint32Array, + Uint16Array, + Uint8Array +]; +webGLArrayContentGenerators = [randomLength, randomSmallIntArray]; +randomWebGLArray = function() { + var t = WebGLArrayTypes.random(); + return new t(webGLArrayContentGenerators.random()()); +}; + +randomArrayBuffer = function(buflen) { + if (buflen == null) buflen = 256; + var len = randomInt(buflen)+1; + var rv; + try { + rv = new ArrayBuffer(len); + } catch(e) { + log("Error creating ArrayBuffer with length " + len); + throw(e); + } + return rv; +}; + +bufferDataGenerators = [randomLength, randomWebGLArray, randomArrayBuffer]; +randomBufferData = function() { + return bufferDataGenerators.random()(); +}; + +randomSmallWebGLArray = function(buflen) { + var t = WebGLArrayTypes.random(); + return new t(randomInt(buflen/4)+1); +}; + +bufferSubDataGenerators = [randomSmallWebGLArray, randomArrayBuffer]; +randomBufferSubData = function(buflen) { + var data = bufferSubDataGenerators.random()(buflen); + var offset = randomInt(buflen - data.byteLength); + return {data:data, offset:offset}; +}; + +randomColor = function() { + return [Math.random(), Math.random(), Math.random(), Math.random()]; +}; + +randomName = function() { + var arr = []; + var len = randomLength()+1; + for (var i=0; i<len; i++) { + var l = randomInt(255)+1; + var h = randomInt(255)+1; + var c = (h << 8) | l; + arr.push(String.fromCharCode(c)); + } + return arr.join(''); +}; +randomVertexAttribute = function() { + return randomInt(MaxVertexAttribs); +}; + +randomBool = function() { return Math.random() > 0.5; }; + +randomStencil = function() { + return randomInt(MaxStencilValue); +}; + +randomLineWidth = function() { + var lo = LineWidthRange[0], + hi = LineWidthRange[1]; + return randomFloatFromRange(lo, hi); +}; + +randomImage = function(w,h) { + var img; + var r = Math.random(); + if (r < 0.25) { + img = document.createElement('canvas'); + img.width = w; img.height = h; + img.getContext('2d').fillRect(0,0,w,h); + } else if (r < 0.5) { + img = document.createElement('video'); + img.muted = true; + img.width = w; img.height = h; + } else if (r < 0.75) { + img = document.createElement('img'); + img.width = w; img.height = h; + } else { + img = canvas2D.getContext('2d').createImageData(w,h); + } + return img +}; + +mutateArgs = function(args) { + var mutateCount = randomIntFromRange(1, args.length); + var newArgs = Array.from(args); + for (var i=0; i<mutateCount; i++) { + var idx = randomInt(args.length); + newArgs[idx] = generateRandomArg(idx, args.length); + } + return newArgs; +}; + +// Calls testFunction numberOfTests times with arguments generated by +// argGen.generate() (or empty arguments if no generate present). +// +// The arguments testFunction is called with are the generated args, +// the argGen, and what argGen.setup() returned or [] if argGen has not setup +// method. I.e. testFunction(generatedArgs, argGen, setupVars). +// +argGeneratorTestRunner = function(argGen, testFunction, numberOfTests) { + // do argument generator setup if needed + var setupVars = argGen.setup ? argGen.setup() : []; + var error; + for (var i=0; i<numberOfTests; i++) { + var failed = false; + // generate arguments if argGen has a generate method + var generatedArgs = argGen.generate ? argGen.generate.apply(argGen, setupVars) : []; + try { + // call testFunction with the generated args + testFunction.call(this, generatedArgs, argGen, setupVars); + } catch (e) { + failed = true; + error = e; + } + // if argGen needs cleanup for generated args, do it here + if (argGen.cleanup) + argGen.cleanup.apply(argGen, generatedArgs); + if (failed) break; + } + // if argGen needs to do a final cleanup for setupVars, do it here + if (argGen.teardown) + argGen.teardown.apply(argGen, setupVars); + if (error) throw(error); +}; + +// TODO: Remove this +// WebKit or at least Chrome is really slow at laying out strings with +// unprintable characters. Without this tests can take 30-90 seconds. +// With this they're instant. +sanitize = function(str) { + var newStr = []; + for (var ii = 0; ii < str.length; ++ii) { + var c = str.charCodeAt(ii); + newStr.push((c > 31 && c < 128) ? str[ii] : "?"); + } + return newStr.join(''); +}; + +argsToString = function(args) { + return sanitize(args.map(function(a){return Object.toSource(a)}).join(",")); +}; diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPIBadArgs.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPIBadArgs.html new file mode 100644 index 0000000000..fb65bf2ad1 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/quickCheckAPIBadArgs.html @@ -0,0 +1,82 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> +<script type="application/javascript" src="quickCheckAPI.js"></script> + +<script type="application/javascript"> + +// Test that all GL functions specified in ArgGenerators fail +// when called with randomly generated invalid arguments +// Works only on tests with checkArgValidity defined +Tests.testInvalidArgs = function() { + var randomTestCount = 100; + for (var name in ArgGenerators) { + try { + if (!GL[name]) + throw (new Error(name + " is missing from the WebGL context")); + var argGen = ArgGenerators[name]; + var alreadyTriedArgs = {}; + if (!argGen.generate || !argGen.checkArgValidity) continue; + // test each GL function with randomTestCount randomly generated valid args + argGeneratorTestRunner(argGen, function(args, gen, setupVars) { + var mutatedArgs; + var foundArgs = false; + for (var j=0; j<100; j++) { + mutatedArgs = mutateArgs(args); + var validArgs = false; + try { + validArgs = gen.checkArgValidity.apply(gen, mutatedArgs); + } catch(e) {} + if (!validArgs) { + if (gen.noAlreadyTriedCheck) { + foundArgs = true; + break; // found new invalid args + } + var src = Object.toSource(mutatedArgs); + if (!alreadyTriedArgs[src]) { + alreadyTriedArgs[src] = true; + foundArgs = true; + break; // found new invalid args + } + } + } + if (!foundArgs) + return true; + var ok = false; + var rv; + // assert that GL function fails when called with invalid args + assertFail("This should fail: "+name+"("+argsToString(mutatedArgs)+")", + function(){ + GL.getError(); // clear off existing error + rv = GL[name].apply(GL, mutatedArgs); + throwError(GL, name); + ok = true; + }); + // if we need to cleanup the return value, do it here + // e.g. calling gl.deleteBuffer(rv) after testing gl.createBuffer() above + if (gen.returnValueCleanup && rv != null) { + assertOk("Cleaning up return value after "+name+"("+argsToString(mutatedArgs)+")", + function() { gen.returnValueCleanup(rv); }); + } + GL.getError(); + return !ok; + }, argGen.testCount || randomTestCount); + } catch(e) { + testFailed(name, e.name, formatError(e)); + } + } +} + +</script> +<style>canvas{position:absolute;}</style> +</head><body> +</body></html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/webGLArrays.html b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/webGLArrays.html new file mode 100644 index 0000000000..bd3eba036d --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance/more/conformance/webGLArrays.html @@ -0,0 +1,165 @@ +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<link rel="stylesheet" type="text/css" href="../unit.css" /> +<script type="application/javascript" src="../unit.js"></script> +<script type="application/javascript" src="../util.js"></script> + +<script type="application/javascript"> + +function assertIdxs(name, arr, length) { +// assertOk(name+": Read with negative idx should work", function(){ return arr[-1] }); +// assertOk(name+": Read with too large idx should work", function(){ return arr[length] }); +// assertOk(name+": Write with negative idx should work", function(){ arr[-1] = 0 }); +// assertOk(name+": Write with too large idx should work", function(){ arr[length] = 0 }); +// arr[0] = 2; +// assertEquals(name+": Test that write worked", 2, arr[0]); +// assertOk(name+": Write with bad value should work", function(){ arr[0] = {x:"foo"} }); +// assertEquals(name+": Test that bad write didn't work", 2, arr[0]); + assertOk(name+": Read and writes with OK idxs should work", function(){ + for (var i=0; i<length; i++) arr[i] = i + 1; + for (var i=0; i<length; i++) arr[i] = arr[i] + 1; + for (var i=0; i<length; i++) assertEquals(name+": Test that reads and writes work", i+2, arr[i]); + }); +} + +Tests.startUnit = function () { + var canvas = document.getElementById('gl'); + var gl = wrapGLContext(getGLContext(canvas)); + prog = new Shader(gl, 'vert', 'frag'); + prog.use(); + prog.uniform4f('c', 255, 0, 0, 255); + va = prog.attrib('Vertex'); + buffer = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, buffer); + return [gl]; +} + +Tests.endUnit = function() { + prog.destroy(); +} + +Tests.testCreateFromArray = function() { + var a = new Float32Array([1,2,3,4,5,6]); + assertIdxs('Float', a, 6); + var a = new Int32Array([1,2,3,4,5,6]); + assertIdxs('Int', a, 6); + var a = new Int16Array([1,2,3,4,5,6]); + assertIdxs('Short', a, 6); + var a = new Int8Array([1,2,3,4,5,6]); + assertIdxs('Byte', a, 6); + var a = new Uint32Array([1,2,3,4,5,6]); + assertIdxs('UInt', a, 6); + var a = new Uint16Array([1,2,3,4,5,6]); + assertIdxs('UShort', a, 6); + var a = new Uint8Array([1,2,3,4,5,6]); + assertIdxs('UByte', a, 6); +} +Tests.testCreateFromCount = function() { + var a = new Float32Array(6); + assertIdxs('Float', a, 6); + var a = new Int32Array(6); + assertIdxs('Int', a, 6); + var a = new Int16Array(6); + assertIdxs('Short', a, 6); + var a = new Int8Array(6); + assertIdxs('Byte', a, 6); + var a = new Uint32Array(6); + assertIdxs('UInt', a, 6); + var a = new Uint16Array(6); + assertIdxs('UShort', a, 6); + var a = new Uint8Array(6); + assertIdxs('UByte', a, 6); +} +Tests.testCreateFromBuffer = function() { + var sz = 24; + var b = new ArrayBuffer(sz); + var a = new Float32Array(b); + assertIdxs('Float', a, sz/4); + var a = new Int32Array(b); + assertIdxs('Int', a, sz/4); + var a = new Int16Array(b); + assertIdxs('Short', a, sz/2); + var a = new Int8Array(b); + assertIdxs('Byte', a, sz/1); + var a = new Uint32Array(b); + assertIdxs('UInt', a, sz/4); + var a = new Uint16Array(b); + assertIdxs('UShort', a, sz/2); + var a = new Uint8Array(b); + assertIdxs('UByte', a, sz/1); +} + +Tests.testThatWritesChangeDrawing = function(gl) { + var verts = [ + 0,0, + 1,0, + 1,1, + + 0,0, + 1,1, + 0,1 + ]; + var a = new Float32Array(verts); + var arr = []; + for (var i=0; i<12; i++) + arr[i] = a[i]; + assertEquals("Test that reads work from an array-initialized Float32Array", arr, verts); + gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); + gl.bufferData(gl.ARRAY_BUFFER, a, gl.STATIC_DRAW); + gl.vertexAttribPointer(va, 2, gl.FLOAT, false, 0, 0); + gl.enableVertexAttribArray(va); + + var id = new Uint8Array(4); + gl.readPixels(8,8,1,1,gl.RGBA, gl.UNSIGNED_BYTE, id); + assertEquals([0, 0, 0, 0], [id[0], id[1], id[2], id[3]]); + + gl.drawArrays(gl.TRIANGLES, 0, 6); + + gl.readPixels(8,8,1,1,gl.RGBA, gl.UNSIGNED_BYTE, id); + assertEquals([255, 0, 0, 255], [id[0], id[1], id[2], id[3]]); + gl.readPixels(0,8,1,1,gl.RGBA, gl.UNSIGNED_BYTE, id); + assertEquals([0, 0, 0, 0], [id[0], id[1], id[2], id[3]]); + + a[0] = a[6] = a[10] = -1; + gl.bufferData(gl.ARRAY_BUFFER, a, gl.STATIC_DRAW); + gl.vertexAttribPointer(va, 2, gl.FLOAT, false, 0, 0); + + gl.drawArrays(gl.TRIANGLES, 0, 6); + + gl.readPixels(8,8,1,1,gl.RGBA, gl.UNSIGNED_BYTE, id); + assertEquals([255, 0, 0, 255], [id[0], id[1], id[2], id[3]]); + gl.readPixels(0,8,1,1,gl.RGBA, gl.UNSIGNED_BYTE, id); + assertEquals("Test that Float32Array#[]= worked and drawArrays drew a full-width rectangle", + [255, 0, 0, 255], [id[0], id[1], id[2], id[3]]); + gl.readPixels(0,0,1,1,gl.RGBA, gl.UNSIGNED_BYTE, id); + assertEquals([0, 0, 0, 0], [id[0], id[1], id[2], id[3]]); +} + +</script> +<script id="vert" type="x-shader/x-vertex"> + attribute vec2 Vertex; + void main() + { + gl_Position = vec4(Vertex, 0.0, 1.0); + } +</script> +<script id="frag" type="x-shader/x-fragment"> + precision mediump float; + + uniform vec4 c; + void main() + { + gl_FragColor = c; + } +</script> +<style>canvas{border: 1px solid black}</style> +</head><body> +<canvas id="gl" width="16" height="16"></canvas> +</body></html> |