1 files changed, 409 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fIndexedStateQueryTests.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fIndexedStateQueryTests.js
new file mode 100644
index 0000000000..a18f6708b2
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fIndexedStateQueryTests.js
@@ -0,0 +1,409 @@
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program OpenGL ES Utilities
+ * ------------------------------------------------
+ *
+ * Copyright 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License');
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an 'AS IS' BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+'use strict';
+goog.provide('functional.gles3.es3fIndexedStateQueryTests');
+goog.require('framework.common.tcuTestCase');
+goog.require('functional.gles3.es3fApiCase');
+
+goog.scope(function() {
+	var es3fIndexedStateQueryTests = functional.gles3.es3fIndexedStateQueryTests;
+    var tcuTestCase = framework.common.tcuTestCase;
+    var es3fApiCase = functional.gles3.es3fApiCase;
+
+	/**
+	 * @constructor
+	 * @extends {es3fApiCase.ApiCase}
+	 * @param {string} name
+	 * @param {string} description
+	 */
+	es3fIndexedStateQueryTests.TransformFeedbackCase = function(name, description) {
+		es3fApiCase.ApiCase.call(this, name, description, gl);
+	};
+
+	es3fIndexedStateQueryTests.TransformFeedbackCase.prototype = Object.create(es3fApiCase.ApiCase.prototype);
+	es3fIndexedStateQueryTests.TransformFeedbackCase.prototype.constructor = es3fIndexedStateQueryTests.TransformFeedbackCase;
+
+	es3fIndexedStateQueryTests.TransformFeedbackCase.prototype.testTransformFeedback = function() {
+		throw new Error('This method should be overriden.');
+	};
+
+	es3fIndexedStateQueryTests.TransformFeedbackCase.prototype.test = function() {
+		/** @type {string} */ var transformFeedbackTestVertSource = '' +
+			'#version 300 es\n' +
+			'out highp vec4 anotherOutput;\n' +
+			'void main (void)\n' +
+			'{\n' +
+			'	gl_Position = vec4(0.0);\n' +
+			'	anotherOutput = vec4(0.0);\n' +
+			'}\n';
+		/** @type {string} */ var transformFeedbackTestFragSource = '' +
+			'#version 300 es\n' +
+			'layout(location = 0) out mediump vec4 fragColor;' +
+			'void main (void)\n' +
+			'{\n' +
+			'	fragColor = vec4(0.0);\n' +
+			'}\n';
+
+		/** @type {WebGLShader} */ var shaderVert = gl.createShader(gl.VERTEX_SHADER);
+		/** @type {WebGLShader} */ var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);
+
+		gl.shaderSource(shaderVert, transformFeedbackTestVertSource);
+		gl.shaderSource(shaderFrag, transformFeedbackTestFragSource);
+
+		gl.compileShader(shaderVert);
+		gl.compileShader(shaderFrag);
+
+		/** @type {WebGLProgram} */ var shaderProg = gl.createProgram();
+		gl.attachShader(shaderProg, shaderVert);
+		gl.attachShader(shaderProg, shaderFrag);
+
+		/** @type {Array<string>} */ var transformFeedbackOutputs = ['gl_Position', 'anotherOutput'];
+
+		gl.transformFeedbackVaryings(shaderProg, transformFeedbackOutputs, gl.INTERLEAVED_ATTRIBS);
+		gl.linkProgram(shaderProg);
+
+		/** @type {WebGLTransformFeedback} */ var transformFeedbackId = gl.createTransformFeedback();
+		gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, transformFeedbackId);
+
+		this.testTransformFeedback();
+
+		// cleanup
+
+		gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
+
+		gl.deleteTransformFeedback(transformFeedbackId);
+		gl.deleteShader(shaderVert);
+		gl.deleteShader(shaderFrag);
+		gl.deleteProgram(shaderProg);
+	};
+
+	/**
+	 * @constructor
+	 * @extends {es3fIndexedStateQueryTests.TransformFeedbackCase}
+	 * @param {string} name
+	 * @param {string} description
+	 */
+	es3fIndexedStateQueryTests.TransformFeedbackBufferBindingCase = function(name, description) {
+		es3fIndexedStateQueryTests.TransformFeedbackCase.call(this, name, description);
+	};
+
+	es3fIndexedStateQueryTests.TransformFeedbackBufferBindingCase.prototype = Object.create(es3fIndexedStateQueryTests.TransformFeedbackCase.prototype);
+	es3fIndexedStateQueryTests.TransformFeedbackBufferBindingCase.prototype.constructor = es3fIndexedStateQueryTests.TransformFeedbackBufferBindingCase;
+
+	es3fIndexedStateQueryTests.TransformFeedbackBufferBindingCase.prototype.testTransformFeedback = function() {
+		/** @type {number} */ var feedbackPositionIndex = 0;
+		/** @type {number} */ var feedbackOutputIndex = 1;
+		/** @type {Array<number>} */ var feedbackIndex = [feedbackPositionIndex, feedbackOutputIndex];
+
+		// bind buffers
+
+		/** @type {Array<WebGLBuffer>} */ var feedbackBuffers = [];
+		for (var ndx = 0; ndx < 2; ndx++)
+			feedbackBuffers[ndx] = gl.createBuffer();
+
+		for (var ndx = 0; ndx < feedbackBuffers.length; ndx++) {
+			gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, feedbackBuffers[ndx]);
+			gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, new Float32Array(16), gl.DYNAMIC_READ);
+			gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, feedbackIndex[ndx], feedbackBuffers[ndx]);
+		}
+
+		// test TRANSFORM_FEEDBACK_BUFFER_BINDING
+		for (var ndx = 0; ndx < feedbackBuffers.length; ndx++) {
+			var boundBuffer = /** @type {WebGLBuffer} */ (gl.getIndexedParameter(gl.TRANSFORM_FEEDBACK_BUFFER_BINDING, ndx));
+			this.check(boundBuffer === feedbackBuffers[ndx], 'buffers do not match');
+		}
+
+		// cleanup
+		for (var ndx = 0; ndx < feedbackBuffers.length; ndx++)
+			gl.deleteBuffer(feedbackBuffers[ndx]);
+	};
+
+	/**
+	 * @constructor
+	 * @extends {es3fIndexedStateQueryTests.TransformFeedbackCase}
+	 * @param {string} name
+	 * @param {string} description
+	 */
+	es3fIndexedStateQueryTests.TransformFeedbackBufferBufferCase = function(name, description) {
+		es3fIndexedStateQueryTests.TransformFeedbackCase.call(this, name, description);
+	};
+
+	es3fIndexedStateQueryTests.TransformFeedbackBufferBufferCase.prototype = Object.create(es3fIndexedStateQueryTests.TransformFeedbackCase.prototype);
+	es3fIndexedStateQueryTests.TransformFeedbackBufferBufferCase.prototype.constructor = es3fIndexedStateQueryTests.TransformFeedbackBufferBufferCase;
+
+	es3fIndexedStateQueryTests.TransformFeedbackBufferBufferCase.prototype.testTransformFeedback = function() {
+		/** @type {number} */ var feedbackPositionIndex = 0;
+		/** @type {number} */ var feedbackOutputIndex = 1;
+
+		/** @type {number} */ var rangeBufferOffset = 4;
+		/** @type {number} */ var rangeBufferSize = 8;
+
+		// bind buffers
+
+		/** @type {Array<WebGLBuffer>} */ var feedbackBuffers = [];
+		for (var ndx = 0; ndx < 2; ndx++)
+			feedbackBuffers[ndx] = gl.createBuffer();
+
+		gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, feedbackBuffers[0]);
+		gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, new Float32Array(16), gl.DYNAMIC_READ);
+		gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, feedbackPositionIndex, feedbackBuffers[0]);
+
+		gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, feedbackBuffers[1]);
+		gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, new Float32Array(16), gl.DYNAMIC_READ);
+		gl.bindBufferRange(gl.TRANSFORM_FEEDBACK_BUFFER, feedbackOutputIndex, feedbackBuffers[1], rangeBufferOffset, rangeBufferSize);
+
+		/** @type {Array<{index: number, pname: number, value: number}>} */ var requirements = [
+			{index: feedbackPositionIndex, pname: gl.TRANSFORM_FEEDBACK_BUFFER_START, value: 0},
+			{index: feedbackPositionIndex, pname: gl.TRANSFORM_FEEDBACK_BUFFER_SIZE, value: 0},
+			{index: feedbackOutputIndex, pname: gl.TRANSFORM_FEEDBACK_BUFFER_START, value: rangeBufferOffset},
+			{index: feedbackOutputIndex, pname: gl.TRANSFORM_FEEDBACK_BUFFER_SIZE, value: rangeBufferSize}
+		];
+
+		for (var ndx = 0; ndx < requirements.length; ndx++) {
+			var state = /** @type {number} */ (gl.getIndexedParameter(requirements[ndx].pname, requirements[ndx].index));
+			this.check(state === requirements[ndx].value, 'got ' + state + '; expected ' + requirements[ndx].value);
+		}
+
+		// cleanup
+		for (var ndx = 0; ndx < feedbackBuffers.length; ndx++)
+			gl.deleteBuffer(feedbackBuffers[ndx]);
+	};
+
+	/**
+	 * @constructor
+	 * @extends {es3fApiCase.ApiCase}
+	 * @param {string} name
+	 * @param {string} description
+	 */
+	es3fIndexedStateQueryTests.UniformBufferCase = function(name, description) {
+		es3fApiCase.ApiCase.call(this, name, description, gl);
+		/** @type {?WebGLProgram} */ this.m_program = null;
+	};
+
+	es3fIndexedStateQueryTests.UniformBufferCase.prototype = Object.create(es3fApiCase.ApiCase.prototype);
+	es3fIndexedStateQueryTests.UniformBufferCase.prototype.constructor = es3fIndexedStateQueryTests.UniformBufferCase;
+
+	es3fIndexedStateQueryTests.UniformBufferCase.prototype.testUniformBuffers = function() {
+		throw new Error('This method should be overriden.');
+	};
+
+	es3fIndexedStateQueryTests.UniformBufferCase.prototype.test = function() {
+
+		/** @type {string} */ var testVertSource = '' +
+			'#version 300 es\n' +
+			'uniform highp vec4 input1;\n' +
+			'uniform highp vec4 input2;\n' +
+			'void main (void)\n' +
+			'{\n' +
+			'	gl_Position = input1 + input2;\n' +
+			'}\n';
+		/** @type {string} */ var testFragSource = '' +
+			'#version 300 es\n' +
+			'layout(location = 0) out mediump vec4 fragColor;' +
+			'void main (void)\n' +
+			'{\n' +
+			'	fragColor = vec4(0.0);\n' +
+			'}\n';
+
+		/** @type {WebGLShader} */ var shaderVert = gl.createShader(gl.VERTEX_SHADER);
+		/** @type {WebGLShader} */ var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);
+
+		gl.shaderSource(shaderVert, testVertSource);
+		gl.shaderSource(shaderFrag, testFragSource);
+
+		gl.compileShader(shaderVert);
+		gl.compileShader(shaderFrag);
+
+		this.m_program = gl.createProgram();
+		gl.attachShader(this.m_program, shaderVert);
+		gl.attachShader(this.m_program, shaderFrag);
+		gl.linkProgram(this.m_program);
+		gl.useProgram(this.m_program);
+
+		this.testUniformBuffers();
+
+		gl.useProgram(null);
+		gl.deleteShader(shaderVert);
+		gl.deleteShader(shaderFrag);
+		gl.deleteProgram(this.m_program);
+	};
+
+	/**
+	* @constructor
+	* @extends {es3fIndexedStateQueryTests.UniformBufferCase}
+	* @param {string} name
+	* @param {string} description
+	*/
+	es3fIndexedStateQueryTests.UniformBufferBindingCase = function(name, description) {
+		es3fIndexedStateQueryTests.UniformBufferCase.call(this, name, description);
+		/** @type {?WebGLProgram} */ this.m_program = null;
+	};
+
+	es3fIndexedStateQueryTests.UniformBufferBindingCase.prototype = Object.create(es3fIndexedStateQueryTests.UniformBufferCase.prototype);
+	es3fIndexedStateQueryTests.UniformBufferBindingCase.prototype.constructor = es3fIndexedStateQueryTests.UniformBufferBindingCase;
+
+	es3fIndexedStateQueryTests.UniformBufferBindingCase.prototype.testUniformBuffers = function() {
+		/** @type {Array<string>} */ var uniformNames = ['input1', 'input2'];
+
+		/** @type {Array<number>} */ var uniformIndices = gl.getUniformIndices(this.m_program, uniformNames);
+
+		/** @type {Array<WebGLBuffer>} */ var buffers = [];
+		for (var ndx = 0; ndx < 2; ndx++)
+			buffers[ndx] = gl.createBuffer();
+
+		for (var ndx = 0; ndx < buffers.length; ++ndx) {
+			gl.bindBuffer(gl.UNIFORM_BUFFER, buffers[ndx]);
+			gl.bufferData(gl.UNIFORM_BUFFER, new Float32Array(32), gl.DYNAMIC_DRAW);
+			gl.bindBufferBase(gl.UNIFORM_BUFFER, uniformIndices[ndx], buffers[ndx]);
+		}
+
+		/** @type {Array<WebGLBuffer>} */ var boundBuffer = [];
+		for (var ndx = 0; ndx < buffers.length; ndx++) {
+			boundBuffer[ndx] = /** @type {WebGLBuffer} */ (gl.getIndexedParameter(gl.UNIFORM_BUFFER_BINDING, uniformIndices[ndx]));
+			this.check(boundBuffer[ndx] === buffers[ndx], 'buffers do not match');
+		}
+
+		for (var ndx = 0; ndx < buffers.length; ndx++)
+			gl.deleteBuffer(buffers[ndx]);
+	};
+
+	/**
+	* @constructor
+	* @extends {es3fIndexedStateQueryTests.UniformBufferCase}
+	* @param {string} name
+	* @param {string} description
+	*/
+	es3fIndexedStateQueryTests.UniformBufferBufferCase = function(name, description) {
+		es3fIndexedStateQueryTests.UniformBufferCase.call(this, name, description);
+		/** @type {?WebGLProgram} */ this.m_program = null;
+	};
+
+	es3fIndexedStateQueryTests.UniformBufferBufferCase.prototype = Object.create(es3fIndexedStateQueryTests.UniformBufferCase.prototype);
+	es3fIndexedStateQueryTests.UniformBufferBufferCase.prototype.constructor = es3fIndexedStateQueryTests.UniformBufferBufferCase;
+
+	es3fIndexedStateQueryTests.UniformBufferBufferCase.prototype.testUniformBuffers = function() {
+		/** @type {Array<string>} */ var uniformNames = ['input1', 'input2'];
+
+		/** @type {Array<number>} */ var uniformIndices = gl.getUniformIndices(this.m_program, uniformNames);
+
+		/** @type {number} */ var alignment = this.getAlignment();
+		if (alignment === -1) // cannot continue without this
+			return;
+
+		bufferedLogToConsole('Alignment is ' + alignment);
+
+		/** @type {number} */ var rangeBufferOffset = alignment;
+		/** @type {number} */ var rangeBufferSize = alignment * 2;
+		/** @type {number} */ var rangeBufferTotalSize = rangeBufferOffset + rangeBufferSize + 8; // + 8 has no special meaning, just to make it != with the size of the range
+
+		/** @type {Array<WebGLBuffer>} */ var buffers = [];
+		for (var ndx = 0; ndx < 2; ndx++)
+			buffers[ndx] = gl.createBuffer();
+
+		gl.bindBuffer(gl.UNIFORM_BUFFER, buffers[0]);
+		gl.bufferData(gl.UNIFORM_BUFFER, new Float32Array(32), gl.DYNAMIC_DRAW);
+		gl.bindBufferBase(gl.UNIFORM_BUFFER, uniformIndices[0], buffers[0]);
+
+		gl.bindBuffer(gl.UNIFORM_BUFFER, buffers[1]);
+		gl.bufferData(gl.UNIFORM_BUFFER, new Float32Array(32), gl.DYNAMIC_DRAW);
+		gl.bindBufferRange(gl.UNIFORM_BUFFER, uniformIndices[1], buffers[1], rangeBufferOffset, rangeBufferSize);
+
+		// test UNIFORM_BUFFER_START and UNIFORM_BUFFER_SIZE
+
+		/** @type {Array<{index: number, pname: number, value: number}>} */ var requirements = [
+			{index: uniformIndices[0], pname: gl.UNIFORM_BUFFER_START, value: 0},
+			{index: uniformIndices[0], pname: gl.UNIFORM_BUFFER_SIZE, value: 0},
+			{index: uniformIndices[1], pname: gl.UNIFORM_BUFFER_START, value: rangeBufferOffset},
+			{index: uniformIndices[1], pname: gl.UNIFORM_BUFFER_SIZE, value: rangeBufferSize}
+		];
+
+		for (var ndx = 0; ndx < requirements.length; ndx++) {
+			var state = /** @type {number} */ (gl.getIndexedParameter(requirements[ndx].pname, requirements[ndx].index));
+
+			this.check(state === requirements[ndx].value, 'got ' + state + '; expected ' + requirements[ndx].value);
+		}
+
+		for (var ndx = 0; ndx < buffers.length; ndx++)
+			gl.deleteBuffer(buffers[ndx]);
+
+	};
+
+	/**
+	 * @return {number}
+	 */
+	es3fIndexedStateQueryTests.UniformBufferBufferCase.prototype.getAlignment = function() {
+		var state = /** @type {number} */ (gl.getParameter(gl.UNIFORM_BUFFER_OFFSET_ALIGNMENT));
+
+		if (state <= 256)
+			return state;
+
+		bufferedLogToConsole('ERROR: UNIFORM_BUFFER_OFFSET_ALIGNMENT has a maximum value of 256.');
+		testFailedOptions('invalid UNIFORM_BUFFER_OFFSET_ALIGNMENT value', false);
+
+		return -1;
+	};
+
+    /**
+    * @constructor
+    * @extends {tcuTestCase.DeqpTest}
+    */
+    es3fIndexedStateQueryTests.IndexedStateQueryTests = function() {
+        tcuTestCase.DeqpTest.call(this, 'indexed', 'Indexed Integer Values');
+    };
+
+    es3fIndexedStateQueryTests.IndexedStateQueryTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
+    es3fIndexedStateQueryTests.IndexedStateQueryTests.prototype.constructor = es3fIndexedStateQueryTests.IndexedStateQueryTests;
+
+    es3fIndexedStateQueryTests.IndexedStateQueryTests.prototype.init = function() {
+		// transform feedback
+		this.addChild(new es3fIndexedStateQueryTests.TransformFeedbackBufferBindingCase('transform_feedback_buffer_binding', 'TRANSFORM_FEEDBACK_BUFFER_BINDING'));
+		this.addChild(new es3fIndexedStateQueryTests.TransformFeedbackBufferBufferCase('transform_feedback_buffer_start_size', 'TRANSFORM_FEEDBACK_BUFFER_START and TRANSFORM_FEEDBACK_BUFFER_SIZE'));
+
+		// uniform buffers
+		this.addChild(new es3fIndexedStateQueryTests.UniformBufferBindingCase('uniform_buffer_binding', 'UNIFORM_BUFFER_BINDING'));
+		this.addChild(new es3fIndexedStateQueryTests.UniformBufferBufferCase('uniform_buffer_start_size', 'UNIFORM_BUFFER_START and UNIFORM_BUFFER_SIZE'));
+    };
+
+    /**
+    * Run test
+    * @param {WebGL2RenderingContext} context
+    */
+    es3fIndexedStateQueryTests.run = function(context) {
+    	gl = context;
+    	//Set up Test Root parameters
+    	var state = tcuTestCase.runner;
+    	state.setRoot(new es3fIndexedStateQueryTests.IndexedStateQueryTests());
+
+    	//Set up name and description of this test series.
+    	setCurrentTestName(state.testCases.fullName());
+    	description(state.testCases.getDescription());
+
+    	try {
+    		//Run test cases
+    		tcuTestCase.runTestCases();
+    	}
+    	catch (err) {
+    		testFailedOptions('Failed to es3fIndexedStateQueryTests.run tests', false);
+    		tcuTestCase.runner.terminate();
+    	}
+    };
+
+});