LayoutTests/webgl/resources/webgl_test_files/conformance2/extensions/oes-draw-buffers-indexed.html - WebKit - Git at Google

 <!--
 Copyright (c) 2020 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.
 -->

 <!DOCTYPE html>
 <html>
 <head>
 <meta charset="utf-8">
 <title>WebGL OES_draw_buffers_indexed Conformance Tests</title>
 <LINK rel="stylesheet" href="../../resources/js-test-style.css"/>
 <script src="../../js/js-test-pre.js"></script>
 <script src="../../js/webgl-test-utils.js"></script>
 </head>
 <body>
 <div id="description"></div>
 <div id="console"></div>
 <script>
 "use strict";
 description("This test verifies the functionality of the OES_draw_buffers_indexed extension, if it is available.");

 debug("");

 var wtu = WebGLTestUtils;
 var canvas = document.getElementById("canvas");
 var gl = wtu.create3DContext(null, null, 2);
 var ext;

 const vs = `#version 300 es
 layout(location=0) in vec4 vPosition;
 void main()
 {
     gl_Position = vPosition;
 }
 `;

 const fs = `#version 300 es
 precision lowp float;
 layout(location = 0) out vec4 o_color0;
 layout(location = 1) out vec4 o_color1;
 void main()
 {
     o_color0 = vec4(1, 0, 0, 0);
     o_color1 = vec4(1, 0, 0, 0);
 }
 `;

 function setup() {
     const program = wtu.setupProgram(gl, [vs, fs]);
     gl.useProgram(program);
     wtu.setupUnitQuad(gl, 0);
     wtu.glErrorShouldBe(gl, 0, 'No errors from program');

     const tex1 = gl.createTexture();
     gl.bindTexture(gl.TEXTURE_2D, tex1);
     gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
     wtu.glErrorShouldBe(gl, 0, 'Create texture 1 successfully');

     const tex2 = gl.createTexture();
     gl.bindTexture(gl.TEXTURE_2D, tex2);
     gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
     wtu.glErrorShouldBe(gl, 0, 'Create texture 2 successfully');

     const attachments = [gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1];

     const fb = gl.createFramebuffer();
     gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
     gl.framebufferTexture2D(gl.FRAMEBUFFER, attachments[0], gl.TEXTURE_2D, tex1, 0);
     gl.framebufferTexture2D(gl.FRAMEBUFFER, attachments[1], gl.TEXTURE_2D, tex2, 0);
     shouldBe('gl.checkFramebufferStatus(gl.FRAMEBUFFER)', 'gl.FRAMEBUFFER_COMPLETE');

     gl.drawBuffers(attachments);
     wtu.glErrorShouldBe(gl, 0, 'Set draw buffers without errors');
 }

 function enableDisableTest() {
     debug("Testing enableiOES/disableiOES");

     // Invalid input
     ext.enableiOES(gl.DEPTH_TEST, 0);
     ext.disableiOES(gl.DEPTH_TEST, 0);
     wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, 'target could only be gl.BLEND');

     gl.disable(gl.BLEND);

     // Valid input
     ext.enableiOES(gl.BLEND, 0);
     shouldBe('gl.isEnabled(gl.BLEND)', 'true');
     ext.disableiOES(gl.BLEND, 0);
     ext.enableiOES(gl.BLEND, 1);
     shouldBe('gl.isEnabled(gl.BLEND)', 'false');
     gl.enable(gl.BLEND);
     shouldBe('gl.isEnabled(gl.BLEND)', 'true');
     wtu.glErrorShouldBe(gl, 0, 'No errors from enable and disable draw buffers blend state');
 }

 function constantAlphaBlendColorValidationTest() {
     debug("Testing CONSTANT_COLOR/ALPHA blend functions limit validation");
     function isConstantColorAndAlphaBlendFunctions(first, second)
     {
         return (first == gl.CONSTANT_COLOR || first == gl.ONE_MINUS_CONSTANT_COLOR) &&
             (second == gl.CONSTANT_ALPHA || second == gl.ONE_MINUS_CONSTANT_ALPHA);
     }

     function checkBlendFunctions(src, dst)
     {
         if (isConstantColorAndAlphaBlendFunctions(src, dst) ||
             isConstantColorAndAlphaBlendFunctions(dst, src))
         {
             wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, 'invalid combinations');
             return false;
         }
         else
         {
             wtu.glErrorShouldBe(gl, 0, 'No error');
             return true;
         }
     }

     const srcFunc = [
         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,
     ];

     const dstFunc = [
         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,
     ];

     let src, dst;

     // CONSTANT_COLOR/ALPHA invalid combination check
     for (let i = 0, leni = srcFunc.length; i < leni; i++)
     {
         src = srcFunc[i];
         for (let j = 0, lenj = dstFunc.length; j < lenj; j++)
         {
             dst = dstFunc[j];
             ext.blendFunciOES(0, src, dst);
             checkBlendFunctions(src, dst);
             ext.blendFuncSeparateiOES(0, src, dst, gl.ONE, gl.ONE);
             checkBlendFunctions(src, dst);
         }
     }
 }

 function indexedBlendColorTest() {
     debug("Testing blendEquationiOES and blendFunciOES");
     gl.clearColor(0, 0, 1, 1);
     gl.clear(gl.COLOR_BUFFER_BIT);

     ext.blendEquationiOES(0, gl.FUNC_ADD);
     ext.blendFunciOES(0, gl.ONE, gl.ONE);
     ext.blendEquationiOES(1, gl.FUNC_ADD);
     ext.blendFunciOES(1, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
     gl.drawArrays(gl.TRIANGLES, 0, 6);
     wtu.glErrorShouldBe(gl, 0, 'Draw quad without errors');

     gl.readBuffer(gl.COLOR_ATTACHMENT0);
     wtu.checkCanvasRect(gl, 0, 0, 1, 1, [255, 0, 255, 255]);

     gl.readBuffer(gl.COLOR_ATTACHMENT1);
     wtu.checkCanvasRect(gl, 0, 0, 1, 1, [0, 0, 255, 255]);

     debug("Testing blendEquationSeparateiOES and blendFuncSeparateiOES");
     gl.clear(gl.COLOR_BUFFER_BIT);

     ext.blendEquationSeparateiOES(0, gl.FUNC_ADD, gl.FUNC_SUBTRACT);
     ext.blendFuncSeparateiOES(0, gl.ONE, gl.ONE, gl.ZERO, gl.ZERO);
     ext.blendEquationSeparateiOES(1, gl.FUNC_ADD, gl.FUNC_SUBTRACT);
     ext.blendFuncSeparateiOES(1, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ZERO, gl.ZERO);
     gl.drawArrays(gl.TRIANGLES, 0, 6);
     wtu.glErrorShouldBe(gl, 0, 'Draw quad without errors');

     gl.readBuffer(gl.COLOR_ATTACHMENT0);
     wtu.checkCanvasRect(gl, 0, 0, 1, 1, [255, 0, 255, 0]);

     gl.readBuffer(gl.COLOR_ATTACHMENT1);
     wtu.checkCanvasRect(gl, 0, 0, 1, 1, [0, 0, 255, 0]);

     debug("Testing colorMaskiOES");
     gl.clear(gl.COLOR_BUFFER_BIT);
     ext.colorMaskiOES(0, false, false, false, false);
     ext.colorMaskiOES(1, true, true, true, true);

     gl.drawArrays(gl.TRIANGLES, 0, 6);
     wtu.glErrorShouldBe(gl, 0, 'Draw quad without errors');

     gl.readBuffer(gl.COLOR_ATTACHMENT0);
     wtu.checkCanvasRect(gl, 0, 0, 1, 1, [0, 0, 255, 255]);

     gl.readBuffer(gl.COLOR_ATTACHMENT1);
     wtu.checkCanvasRect(gl, 0, 0, 1, 1, [0, 0, 255, 0]);

     debug("Testing new tokens for getIndexedParameterTest");
     shouldBe('gl.getIndexedParameter(ext.BLEND_EQUATION_RGB, 0)', 'gl.FUNC_ADD');
     shouldBe('gl.getIndexedParameter(ext.BLEND_EQUATION_ALPHA, 0)', 'gl.FUNC_SUBTRACT');
     shouldBe('gl.getIndexedParameter(ext.BLEND_SRC_RGB, 0)', 'gl.ONE');
     shouldBe('gl.getIndexedParameter(ext.BLEND_DST_RGB, 0)', 'gl.ONE');
     shouldBe('gl.getIndexedParameter(ext.BLEND_SRC_ALPHA, 0)', 'gl.ZERO');
     shouldBe('gl.getIndexedParameter(ext.BLEND_DST_ALPHA, 0)', 'gl.ZERO');
     shouldBe('gl.getIndexedParameter(ext.BLEND_EQUATION_RGB, 1)', 'gl.FUNC_ADD');
     shouldBe('gl.getIndexedParameter(ext.BLEND_EQUATION_ALPHA, 1)', 'gl.FUNC_SUBTRACT');
     shouldBe('gl.getIndexedParameter(ext.BLEND_SRC_RGB, 1)', 'gl.SRC_ALPHA');
     shouldBe('gl.getIndexedParameter(ext.BLEND_DST_RGB, 1)', 'gl.ONE_MINUS_SRC_ALPHA');
     shouldBe('gl.getIndexedParameter(ext.BLEND_SRC_ALPHA, 1)', 'gl.ZERO');
     shouldBe('gl.getIndexedParameter(ext.BLEND_DST_ALPHA, 1)', 'gl.ZERO');

     shouldBe('gl.getIndexedParameter(ext.COLOR_WRITEMASK, 0)', '[false, false, false, false]');
     shouldBe('gl.getIndexedParameter(ext.COLOR_WRITEMASK, 1)', '[true, true, true, true]');

     debug("Testing non-indexed getParamter get state from draw buffer 0");
     shouldBe('gl.getParameter(gl.BLEND_SRC_RGB)', 'gl.ONE');
     shouldBe('gl.getParameter(gl.BLEND_DST_RGB)', 'gl.ONE');
     shouldBe('gl.getParameter(gl.BLEND_SRC_ALPHA)', 'gl.ZERO');
     shouldBe('gl.getParameter(gl.BLEND_DST_ALPHA)', 'gl.ZERO');
     shouldBe('gl.getParameter(gl.BLEND_EQUATION_RGB)', 'gl.FUNC_ADD');
     shouldBe('gl.getParameter(gl.BLEND_EQUATION_ALPHA)', 'gl.FUNC_SUBTRACT');
     shouldBe('gl.getParameter(gl.COLOR_WRITEMASK)', '[false, false, false, false]');

     debug("Testing non-indexed calls modify all draw buffers state");
     gl.blendEquationSeparate(gl.FUNC_SUBTRACT, gl.FUNC_ADD);
     gl.blendFuncSeparate(gl.ONE_MINUS_DST_ALPHA, gl.DST_ALPHA, gl.ONE, gl.ONE);
     gl.colorMask(true, false, true, false);
     wtu.glErrorShouldBe(gl, 0, 'Non-indexed state set without errors');

     shouldBe('gl.getParameter(gl.BLEND_EQUATION_RGB)', 'gl.FUNC_SUBTRACT');
     shouldBe('gl.getParameter(gl.BLEND_EQUATION_ALPHA)', 'gl.FUNC_ADD');
     shouldBe('gl.getParameter(gl.BLEND_SRC_RGB)', 'gl.ONE_MINUS_DST_ALPHA');
     shouldBe('gl.getParameter(gl.BLEND_DST_RGB)', 'gl.DST_ALPHA');
     shouldBe('gl.getParameter(gl.BLEND_SRC_ALPHA)', 'gl.ONE');
     shouldBe('gl.getParameter(gl.BLEND_DST_ALPHA)', 'gl.ONE');
     shouldBe('gl.getParameter(gl.COLOR_WRITEMASK)', '[true, false, true, false]');

     shouldBe('gl.getIndexedParameter(ext.BLEND_EQUATION_RGB, 0)', 'gl.FUNC_SUBTRACT');
     shouldBe('gl.getIndexedParameter(ext.BLEND_EQUATION_ALPHA, 0)', 'gl.FUNC_ADD');
     shouldBe('gl.getIndexedParameter(ext.BLEND_SRC_RGB, 0)', 'gl.ONE_MINUS_DST_ALPHA');
     shouldBe('gl.getIndexedParameter(ext.BLEND_DST_RGB, 0)', 'gl.DST_ALPHA');
     shouldBe('gl.getIndexedParameter(ext.BLEND_SRC_ALPHA, 0)', 'gl.ONE');
     shouldBe('gl.getIndexedParameter(ext.BLEND_DST_ALPHA, 0)', 'gl.ONE');
     shouldBe('gl.getIndexedParameter(ext.BLEND_EQUATION_RGB, 1)', 'gl.FUNC_SUBTRACT');
     shouldBe('gl.getIndexedParameter(ext.BLEND_EQUATION_ALPHA, 1)', 'gl.FUNC_ADD');
     shouldBe('gl.getIndexedParameter(ext.BLEND_SRC_RGB, 1)', 'gl.ONE_MINUS_DST_ALPHA');
     shouldBe('gl.getIndexedParameter(ext.BLEND_DST_RGB, 1)', 'gl.DST_ALPHA');
     shouldBe('gl.getIndexedParameter(ext.BLEND_SRC_ALPHA, 1)', 'gl.ONE');
     shouldBe('gl.getIndexedParameter(ext.BLEND_DST_ALPHA, 1)', 'gl.ONE');

     shouldBe('gl.getIndexedParameter(ext.COLOR_WRITEMASK, 0)', '[true, false, true, false]');
     shouldBe('gl.getIndexedParameter(ext.COLOR_WRITEMASK, 1)', '[true, false, true, false]');
 }

 function runTestExtension() {
     setup();

     enableDisableTest();

     // blending should be enabled for drawBuffers 0 and 1 at this point

     constantAlphaBlendColorValidationTest();

     indexedBlendColorTest();
 }

 function runInvalidEnumsTest() {
     debug("Testing new enums for getIndexedParameterTest being invalid before requesting the extension");
     gl.getIndexedParameter(0x8009, 0);  // BLEND_EQUATION_RGB
     wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, 'BLEND_EQUATION_RGB');
     gl.getIndexedParameter(0x883D, 0);  // BLEND_EQUATION_ALPHA
     wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, 'BLEND_EQUATION_ALPHA');
     gl.getIndexedParameter(0x80C9, 0);  // BLEND_SRC_RGB
     wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, 'BLEND_SRC_RGB');
     gl.getIndexedParameter(0x80CB, 0);  // BLEND_SRC_ALPHA
     wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, 'BLEND_SRC_ALPHA');
     gl.getIndexedParameter(0x80C8, 0);  // BLEND_DST_RGB
     wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, 'BLEND_DST_RGB');
     gl.getIndexedParameter(0x80CA, 0);  // BLEND_DST_ALPHA
     wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, 'BLEND_DST_ALPHA');
     gl.getIndexedParameter(0x0C23, 0);  // COLOR_WRITEMASK
     wtu.glErrorShouldBe(gl, [gl.INVALID_OPERATION, gl.INVALID_ENUM], 'invalid operations or invalid enums for COLOR_WRITEMASK');
 }

 function runTest() {
   if (!gl) {
     testFailed("context does not exist");
   } else {
     testPassed("context exists");

     runInvalidEnumsTest();

     ext = gl.getExtension("OES_draw_buffers_indexed");

     wtu.runExtensionSupportedTest(gl, "OES_draw_buffers_indexed", ext !== null);

     if (ext !== null) {
       runTestExtension();
     } else {
       testPassed("No OES_draw_buffers_indexed support -- this is legal");
     }
   }
 }

 runTest();

 var successfullyParsed = true;
 </script>
 <script src="../../js/js-test-post.js"></script>
 </body>
 </html>
	<!--
	Copyright (c) 2020 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.
	-->

	<!DOCTYPE html>
	<html>
	<head>
	<meta charset="utf-8">
	<title>WebGL OES_draw_buffers_indexed Conformance Tests</title>
	<LINK rel="stylesheet" href="../../resources/js-test-style.css"/>
	<script src="../../js/js-test-pre.js"></script>
	<script src="../../js/webgl-test-utils.js"></script>
	</head>
	<body>
	<div id="description"></div>
	<div id="console"></div>
	<script>
	"use strict";
	description("This test verifies the functionality of the OES_draw_buffers_indexed extension, if it is available.");

	debug("");

	var wtu = WebGLTestUtils;
	var canvas = document.getElementById("canvas");
	var gl = wtu.create3DContext(null, null, 2);
	var ext;

	const vs = `#version 300 es
	layout(location=0) in vec4 vPosition;
	void main()
	{
	gl_Position = vPosition;
	}
	`;

	const fs = `#version 300 es
	precision lowp float;
	layout(location = 0) out vec4 o_color0;
	layout(location = 1) out vec4 o_color1;
	void main()
	{
	o_color0 = vec4(1, 0, 0, 0);
	o_color1 = vec4(1, 0, 0, 0);
	}
	`;

	function setup() {
	const program = wtu.setupProgram(gl, [vs, fs]);
	gl.useProgram(program);
	wtu.setupUnitQuad(gl, 0);
	wtu.glErrorShouldBe(gl, 0, 'No errors from program');

	const tex1 = gl.createTexture();
	gl.bindTexture(gl.TEXTURE_2D, tex1);
	gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
	wtu.glErrorShouldBe(gl, 0, 'Create texture 1 successfully');

	const tex2 = gl.createTexture();
	gl.bindTexture(gl.TEXTURE_2D, tex2);
	gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
	wtu.glErrorShouldBe(gl, 0, 'Create texture 2 successfully');

	const attachments = [gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1];

	const fb = gl.createFramebuffer();
	gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
	gl.framebufferTexture2D(gl.FRAMEBUFFER, attachments[0], gl.TEXTURE_2D, tex1, 0);
	gl.framebufferTexture2D(gl.FRAMEBUFFER, attachments[1], gl.TEXTURE_2D, tex2, 0);
	shouldBe('gl.checkFramebufferStatus(gl.FRAMEBUFFER)', 'gl.FRAMEBUFFER_COMPLETE');

	gl.drawBuffers(attachments);
	wtu.glErrorShouldBe(gl, 0, 'Set draw buffers without errors');
	}

	function enableDisableTest() {
	debug("Testing enableiOES/disableiOES");

	// Invalid input
	ext.enableiOES(gl.DEPTH_TEST, 0);
	ext.disableiOES(gl.DEPTH_TEST, 0);
	wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, 'target could only be gl.BLEND');

	gl.disable(gl.BLEND);

	// Valid input
	ext.enableiOES(gl.BLEND, 0);
	shouldBe('gl.isEnabled(gl.BLEND)', 'true');
	ext.disableiOES(gl.BLEND, 0);
	ext.enableiOES(gl.BLEND, 1);
	shouldBe('gl.isEnabled(gl.BLEND)', 'false');
	gl.enable(gl.BLEND);
	shouldBe('gl.isEnabled(gl.BLEND)', 'true');
	wtu.glErrorShouldBe(gl, 0, 'No errors from enable and disable draw buffers blend state');
	}

	function constantAlphaBlendColorValidationTest() {
	debug("Testing CONSTANT_COLOR/ALPHA blend functions limit validation");
	function isConstantColorAndAlphaBlendFunctions(first, second)
	{
	return (first == gl.CONSTANT_COLOR \|\| first == gl.ONE_MINUS_CONSTANT_COLOR) &&
	(second == gl.CONSTANT_ALPHA \|\| second == gl.ONE_MINUS_CONSTANT_ALPHA);
	}

	function checkBlendFunctions(src, dst)
	{
	if (isConstantColorAndAlphaBlendFunctions(src, dst) \|\|
	isConstantColorAndAlphaBlendFunctions(dst, src))
	{
	wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, 'invalid combinations');
	return false;
	}
	else
	{
	wtu.glErrorShouldBe(gl, 0, 'No error');
	return true;
	}
	}

	const srcFunc = [
	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,
	];

	const dstFunc = [
	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,
	];

	let src, dst;

	// CONSTANT_COLOR/ALPHA invalid combination check
	for (let i = 0, leni = srcFunc.length; i < leni; i++)
	{
	src = srcFunc[i];
	for (let j = 0, lenj = dstFunc.length; j < lenj; j++)
	{
	dst = dstFunc[j];
	ext.blendFunciOES(0, src, dst);
	checkBlendFunctions(src, dst);
	ext.blendFuncSeparateiOES(0, src, dst, gl.ONE, gl.ONE);
	checkBlendFunctions(src, dst);
	}
	}
	}

	function indexedBlendColorTest() {
	debug("Testing blendEquationiOES and blendFunciOES");
	gl.clearColor(0, 0, 1, 1);
	gl.clear(gl.COLOR_BUFFER_BIT);

	ext.blendEquationiOES(0, gl.FUNC_ADD);
	ext.blendFunciOES(0, gl.ONE, gl.ONE);
	ext.blendEquationiOES(1, gl.FUNC_ADD);
	ext.blendFunciOES(1, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
	gl.drawArrays(gl.TRIANGLES, 0, 6);
	wtu.glErrorShouldBe(gl, 0, 'Draw quad without errors');

	gl.readBuffer(gl.COLOR_ATTACHMENT0);
	wtu.checkCanvasRect(gl, 0, 0, 1, 1, [255, 0, 255, 255]);

	gl.readBuffer(gl.COLOR_ATTACHMENT1);
	wtu.checkCanvasRect(gl, 0, 0, 1, 1, [0, 0, 255, 255]);

	debug("Testing blendEquationSeparateiOES and blendFuncSeparateiOES");
	gl.clear(gl.COLOR_BUFFER_BIT);

	ext.blendEquationSeparateiOES(0, gl.FUNC_ADD, gl.FUNC_SUBTRACT);
	ext.blendFuncSeparateiOES(0, gl.ONE, gl.ONE, gl.ZERO, gl.ZERO);
	ext.blendEquationSeparateiOES(1, gl.FUNC_ADD, gl.FUNC_SUBTRACT);
	ext.blendFuncSeparateiOES(1, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ZERO, gl.ZERO);
	gl.drawArrays(gl.TRIANGLES, 0, 6);
	wtu.glErrorShouldBe(gl, 0, 'Draw quad without errors');

	gl.readBuffer(gl.COLOR_ATTACHMENT0);
	wtu.checkCanvasRect(gl, 0, 0, 1, 1, [255, 0, 255, 0]);

	gl.readBuffer(gl.COLOR_ATTACHMENT1);
	wtu.checkCanvasRect(gl, 0, 0, 1, 1, [0, 0, 255, 0]);

	debug("Testing colorMaskiOES");
	gl.clear(gl.COLOR_BUFFER_BIT);
	ext.colorMaskiOES(0, false, false, false, false);
	ext.colorMaskiOES(1, true, true, true, true);

	gl.drawArrays(gl.TRIANGLES, 0, 6);
	wtu.glErrorShouldBe(gl, 0, 'Draw quad without errors');

	gl.readBuffer(gl.COLOR_ATTACHMENT0);
	wtu.checkCanvasRect(gl, 0, 0, 1, 1, [0, 0, 255, 255]);

	gl.readBuffer(gl.COLOR_ATTACHMENT1);
	wtu.checkCanvasRect(gl, 0, 0, 1, 1, [0, 0, 255, 0]);

	debug("Testing new tokens for getIndexedParameterTest");
	shouldBe('gl.getIndexedParameter(ext.BLEND_EQUATION_RGB, 0)', 'gl.FUNC_ADD');
	shouldBe('gl.getIndexedParameter(ext.BLEND_EQUATION_ALPHA, 0)', 'gl.FUNC_SUBTRACT');
	shouldBe('gl.getIndexedParameter(ext.BLEND_SRC_RGB, 0)', 'gl.ONE');
	shouldBe('gl.getIndexedParameter(ext.BLEND_DST_RGB, 0)', 'gl.ONE');
	shouldBe('gl.getIndexedParameter(ext.BLEND_SRC_ALPHA, 0)', 'gl.ZERO');
	shouldBe('gl.getIndexedParameter(ext.BLEND_DST_ALPHA, 0)', 'gl.ZERO');
	shouldBe('gl.getIndexedParameter(ext.BLEND_EQUATION_RGB, 1)', 'gl.FUNC_ADD');
	shouldBe('gl.getIndexedParameter(ext.BLEND_EQUATION_ALPHA, 1)', 'gl.FUNC_SUBTRACT');
	shouldBe('gl.getIndexedParameter(ext.BLEND_SRC_RGB, 1)', 'gl.SRC_ALPHA');
	shouldBe('gl.getIndexedParameter(ext.BLEND_DST_RGB, 1)', 'gl.ONE_MINUS_SRC_ALPHA');
	shouldBe('gl.getIndexedParameter(ext.BLEND_SRC_ALPHA, 1)', 'gl.ZERO');
	shouldBe('gl.getIndexedParameter(ext.BLEND_DST_ALPHA, 1)', 'gl.ZERO');

	shouldBe('gl.getIndexedParameter(ext.COLOR_WRITEMASK, 0)', '[false, false, false, false]');
	shouldBe('gl.getIndexedParameter(ext.COLOR_WRITEMASK, 1)', '[true, true, true, true]');

	debug("Testing non-indexed getParamter get state from draw buffer 0");
	shouldBe('gl.getParameter(gl.BLEND_SRC_RGB)', 'gl.ONE');
	shouldBe('gl.getParameter(gl.BLEND_DST_RGB)', 'gl.ONE');
	shouldBe('gl.getParameter(gl.BLEND_SRC_ALPHA)', 'gl.ZERO');
	shouldBe('gl.getParameter(gl.BLEND_DST_ALPHA)', 'gl.ZERO');
	shouldBe('gl.getParameter(gl.BLEND_EQUATION_RGB)', 'gl.FUNC_ADD');
	shouldBe('gl.getParameter(gl.BLEND_EQUATION_ALPHA)', 'gl.FUNC_SUBTRACT');
	shouldBe('gl.getParameter(gl.COLOR_WRITEMASK)', '[false, false, false, false]');

	debug("Testing non-indexed calls modify all draw buffers state");
	gl.blendEquationSeparate(gl.FUNC_SUBTRACT, gl.FUNC_ADD);
	gl.blendFuncSeparate(gl.ONE_MINUS_DST_ALPHA, gl.DST_ALPHA, gl.ONE, gl.ONE);
	gl.colorMask(true, false, true, false);
	wtu.glErrorShouldBe(gl, 0, 'Non-indexed state set without errors');

	shouldBe('gl.getParameter(gl.BLEND_EQUATION_RGB)', 'gl.FUNC_SUBTRACT');
	shouldBe('gl.getParameter(gl.BLEND_EQUATION_ALPHA)', 'gl.FUNC_ADD');
	shouldBe('gl.getParameter(gl.BLEND_SRC_RGB)', 'gl.ONE_MINUS_DST_ALPHA');
	shouldBe('gl.getParameter(gl.BLEND_DST_RGB)', 'gl.DST_ALPHA');
	shouldBe('gl.getParameter(gl.BLEND_SRC_ALPHA)', 'gl.ONE');
	shouldBe('gl.getParameter(gl.BLEND_DST_ALPHA)', 'gl.ONE');
	shouldBe('gl.getParameter(gl.COLOR_WRITEMASK)', '[true, false, true, false]');

	shouldBe('gl.getIndexedParameter(ext.BLEND_EQUATION_RGB, 0)', 'gl.FUNC_SUBTRACT');
	shouldBe('gl.getIndexedParameter(ext.BLEND_EQUATION_ALPHA, 0)', 'gl.FUNC_ADD');
	shouldBe('gl.getIndexedParameter(ext.BLEND_SRC_RGB, 0)', 'gl.ONE_MINUS_DST_ALPHA');
	shouldBe('gl.getIndexedParameter(ext.BLEND_DST_RGB, 0)', 'gl.DST_ALPHA');
	shouldBe('gl.getIndexedParameter(ext.BLEND_SRC_ALPHA, 0)', 'gl.ONE');
	shouldBe('gl.getIndexedParameter(ext.BLEND_DST_ALPHA, 0)', 'gl.ONE');
	shouldBe('gl.getIndexedParameter(ext.BLEND_EQUATION_RGB, 1)', 'gl.FUNC_SUBTRACT');
	shouldBe('gl.getIndexedParameter(ext.BLEND_EQUATION_ALPHA, 1)', 'gl.FUNC_ADD');
	shouldBe('gl.getIndexedParameter(ext.BLEND_SRC_RGB, 1)', 'gl.ONE_MINUS_DST_ALPHA');
	shouldBe('gl.getIndexedParameter(ext.BLEND_DST_RGB, 1)', 'gl.DST_ALPHA');
	shouldBe('gl.getIndexedParameter(ext.BLEND_SRC_ALPHA, 1)', 'gl.ONE');
	shouldBe('gl.getIndexedParameter(ext.BLEND_DST_ALPHA, 1)', 'gl.ONE');

	shouldBe('gl.getIndexedParameter(ext.COLOR_WRITEMASK, 0)', '[true, false, true, false]');
	shouldBe('gl.getIndexedParameter(ext.COLOR_WRITEMASK, 1)', '[true, false, true, false]');
	}

	function runTestExtension() {
	setup();

	enableDisableTest();

	// blending should be enabled for drawBuffers 0 and 1 at this point

	constantAlphaBlendColorValidationTest();

	indexedBlendColorTest();
	}

	function runInvalidEnumsTest() {
	debug("Testing new enums for getIndexedParameterTest being invalid before requesting the extension");
	gl.getIndexedParameter(0x8009, 0); // BLEND_EQUATION_RGB
	wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, 'BLEND_EQUATION_RGB');
	gl.getIndexedParameter(0x883D, 0); // BLEND_EQUATION_ALPHA
	wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, 'BLEND_EQUATION_ALPHA');
	gl.getIndexedParameter(0x80C9, 0); // BLEND_SRC_RGB
	wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, 'BLEND_SRC_RGB');
	gl.getIndexedParameter(0x80CB, 0); // BLEND_SRC_ALPHA
	wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, 'BLEND_SRC_ALPHA');
	gl.getIndexedParameter(0x80C8, 0); // BLEND_DST_RGB
	wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, 'BLEND_DST_RGB');
	gl.getIndexedParameter(0x80CA, 0); // BLEND_DST_ALPHA
	wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, 'BLEND_DST_ALPHA');
	gl.getIndexedParameter(0x0C23, 0); // COLOR_WRITEMASK
	wtu.glErrorShouldBe(gl, [gl.INVALID_OPERATION, gl.INVALID_ENUM], 'invalid operations or invalid enums for COLOR_WRITEMASK');
	}

	function runTest() {
	if (!gl) {
	testFailed("context does not exist");
	} else {
	testPassed("context exists");

	runInvalidEnumsTest();

	ext = gl.getExtension("OES_draw_buffers_indexed");

	wtu.runExtensionSupportedTest(gl, "OES_draw_buffers_indexed", ext !== null);

	if (ext !== null) {
	runTestExtension();
	} else {
	testPassed("No OES_draw_buffers_indexed support -- this is legal");
	}
	}
	}

	runTest();

	var successfullyParsed = true;
	</script>
	<script src="../../js/js-test-post.js"></script>
	</body>
	</html>