LayoutTests/webgl/2.0.0/resources/webgl_test_files/conformance/reading/read-pixels-test.html - WebKit - Git at Google

 <!--

 /*
 ** Copyright (c) 2012 The Khronos Group Inc.
 **
 ** Permission is hereby granted, free of charge, to any person obtaining a
 ** copy of this software and/or associated documentation files (the
 ** "Materials"), to deal in the Materials without restriction, including
 ** without limitation the rights to use, copy, modify, merge, publish,
 ** distribute, sublicense, and/or sell copies of the Materials, and to
 ** permit persons to whom the Materials are furnished to do so, subject to
 ** the following conditions:
 **
 ** The above copyright notice and this permission notice shall be included
 ** in all copies or substantial portions of the Materials.
 **
 ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
 */

 -->

 <!DOCTYPE html>
 <html>
 <head>
 <meta charset="utf-8">
 <title>WebGL ReadPixels conformance test.</title>
 <link rel="stylesheet" href="../../resources/js-test-style.css"/>
 <script src="../../js/desktop-gl-constants.js"></script>
 <script src="../../js/js-test-pre.js"></script>
 <script src="../../js/webgl-test-utils.js"> </script>
 </head>
 <body>
 <canvas id="example" width="200" height="200" style="width: 20px; height: 20px"></canvas>
 <div id="description"></div>
 <div id="console"></div>
 <script>
 "use strict";
 description("Checks that ReadPixels works as expected.");

 var wtu = WebGLTestUtils;
 var canvas = document.getElementById("example");
 var gl = wtu.create3DContext(canvas);
 var contextVersion = wtu.getDefault3DContextVersion();

 var actual;
 var expected;
 var width = 2;
 var height = 2;
 var continueTestFunc = continueTestPart1;

 gl.clearColor(1, 1, 1, 1);
 gl.clear(gl.COLOR_BUFFER_BIT);

 // Resize the canvas to 2x2. This is an attempt to get stuff in the backbuffer.
 // that shouldn't be there.
 canvas.addEventListener("webglcontextlost", function(e) { e.preventDefault(); }, false);
 canvas.addEventListener("webglcontextrestored", continueTestAfterContextRestored, false);
 canvas.width = width;
 canvas.height = height;
 if (gl.getError() != gl.CONTEXT_LOST_WEBGL) {
   continueTestPart1();
 }

 function continueTestAfterContextRestored() {
   window.gl = wtu.create3DContext(canvas);
   var func = continueTestFunc;
   window.continueTestFunc = function() { testFailed("should not be here"); };
   func();
 }

 function continueTestPart1() {
   gl.clearColor(0.2, 0.6, 0.4, 1);
   gl.clear(gl.COLOR_BUFFER_BIT);

   var innerColor = [51, 153, 102, 255]; // (0.2, 0.6, 0.4, 1)
   var outerColor = [19, 72, 0, 198]; // Random color other than [0, 0, 0, 0]

   var tests = [
     { msg: 'in range', checkColor: innerColor, x:  0, y:  0,
       oneColor: innerColor, oneX: 0, oneY: 0},
     { msg: 'off top left', checkColor: outerColor, x: -1, y: -1,
       oneColor: innerColor, oneX: 1, oneY: 1},
     { msg: 'off bottom right', checkColor: outerColor, x:  1, y:  1,
       oneColor: innerColor, oneX: 0, oneY: 0},
     { msg: 'completely off top ', checkColor: outerColor, x:  0, y: -2,
       oneColor: outerColor, oneX: 0, oneY: 0},
     { msg: 'completely off bottom', checkColor: outerColor, x:  0, y:  2,
       oneColor: outerColor, oneX: 0, oneY: 0},
     { msg: 'completely off left', checkColor: outerColor, x: -2, y:  0,
       oneColor: outerColor, oneX: 0, oneY: 0},
     { msg: 'completeley off right', checkColor: outerColor, x:  2, y:  0,
       oneColor: outerColor, oneX: 0, oneY: 0}
   ];

   for (var tt = 0; tt < tests.length; ++tt) {
     var test = tests[tt];
     debug("");
     debug("checking: " + test.msg);
     checkBuffer(test.checkColor, test.x, test.y,
                 test.oneColor, test.oneX, test.oneY);
   }

   wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no GL errors");

   function checkBuffer(checkColor, x, y, oneColor, oneX, oneY) {
     var buf = new Uint8Array(width * height * 4);
     // Initialize buf.
     for (var ii = 0; ii < width * height; ++ii) {
       buf[ii * 4] = outerColor[0];
       buf[ii * 4 + 1] = outerColor[1];
       buf[ii * 4 + 2] = outerColor[2];
       buf[ii * 4 + 3] = outerColor[3];
     }
     gl.readPixels(x, y, width, height, gl.RGBA, gl.UNSIGNED_BYTE, buf);
     for (var yy = 0; yy < height; ++yy) {
       for (var xx = 0; xx < width; ++xx) {
         var offset = (yy * width + xx) * 4;
         var expectedColors = (oneX == xx && oneY == yy) ? oneColor : checkColor;
         var mismatch = false;
         for (var cc = 0; cc < 4; ++cc) {
           var expectedColor = expectedColors[cc];
           var color = buf[offset + cc];
           var diff = Math.abs(expectedColor - color);
           if (diff >= 3) {
             mismatch = true;
             break;
           }
         }
         assertMsg(!mismatch,
                   "color pixel at " + xx + ", " + yy + " should be about " + expectedColors +
                   ", was = " + [buf[offset], buf[offset + 1], buf[offset + 2], buf[offset + 3]]);
       }
     }
   }

   continueTestPart2();
 }

 function continueTestPart2() {
   var invalidFormat = [gl.DEPTH_COMPONENT, gl.DEPTH_STENCIL, desktopGL.R8, gl.RGBA4, gl.LUMINANCE, gl.LUMINANCE_ALPHA];
   if (contextVersion < 2) {
   // They are valid in WebGL 2 or higher
     invalidFormat = invalidFormat.concat([desktopGL.RED, desktopGL.RG_INTEGER, desktopGL.RGBA_INTEGER]);
   }

   var invalidTypeInfo = [
     {type: desktopGL.UNSIGNED_INT_24_8,       dest: new Uint32Array(4)}
   ];
   if (contextVersion < 2) {
   // They are valid in WebGL 2 or Higher
     invalidTypeInfo = invalidTypeInfo.concat([
       {type: gl.UNSIGNED_SHORT,                     dest: new Uint16Array(4)},
       {type: gl.SHORT,                              dest: new Int16Array(4)},
       {type: gl.BYTE,                               dest: new Int8Array(4)},
       {type: gl.UNSIGNED_INT,                       dest: new Uint32Array(4)},
       {type: desktopGL.UNSIGNED_INT_2_10_10_10_REV, dest: new Uint32Array(4)}
     ]);
   }

   debug("");
   debug("check invalid format or type");
   for (var ff = 0; ff < invalidFormat.length; ++ff) {
     var format = invalidFormat[ff];
     var buf = new Uint8Array(4);
     gl.readPixels(0, 0, 1, 1, format, gl.UNSIGNED_BYTE, buf);
     wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "Should not be able to read as " + wtu.glEnumToString(gl, format));
   }

   for (var tt = 0; tt < invalidTypeInfo.length; ++tt) {
     var info = invalidTypeInfo[tt];
     var type = info.type;
     var dest = info.dest;
     gl.readPixels(0, 0, 1, 1, gl.RGBA, type, dest);
     wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "Should not be able to read as " + wtu.glEnumToString(gl, type));
   }

   var combinations = [
     {
       format: gl.RGBA,
       type: gl.UNSIGNED_BYTE,
       dest: new Uint8Array(4),
     },
     {
       format: gl.RGB,
       type: gl.UNSIGNED_BYTE,
       dest: new Uint8Array(3),
     },
     {
       format: gl.RGB,
       type: gl.UNSIGNED_SHORT_5_6_5,
       dest: new Uint8Array(3),
     },
     {
       format: gl.RGBA,
       type: gl.UNSIGNED_SHORT_5_5_5_1,
       dest: new Uint16Array(1),
     },
     {
       format: gl.RGBA,
       type: gl.UNSIGNED_SHORT_4_4_4_4,
       dest: new Uint16Array(1),
     },
     {
       format: gl.ALPHA,
       type: gl.UNSIGNED_BYTE,
       dest: new Uint8Array(1),
     }
   ];
   if (contextVersion > 1) {
     combinations = combinations.concat([
       {
         format: gl.RED,
         type: gl.UNSIGNED_BYTE,
         dest: new Uint8Array(1),
       },
       {
         format: gl.RGBA_INTEGER,
         type: gl.UNSIGNED_INT,
         dest: new Uint32Array(4),
       },
       {
         format: gl.RGBA_INTEGER,
         type: gl.INT,
         dest: new Int32Array(4),
       }
     ]);
   }

   debug("");
   debug("check invalid combinations of format/type");

   var implFormat = gl.getParameter(gl.IMPLEMENTATION_COLOR_READ_FORMAT);
   var implType = gl.getParameter(gl.IMPLEMENTATION_COLOR_READ_TYPE);

   for (var tt = 0; tt < combinations.length; ++ tt) {
     var info = combinations[tt];
     var format = info.format;
     var type = info.type;
     var dest = info.dest;
     gl.readPixels(0, 0, 1, 1, format, type, dest);
     // Only two format/type parameter pairs are accepted. GL_RGBA/GL_UNSIGNED_BYTE is always
     // accepted on default readbuffer. The other acceptable pair can be discovered by querying
     // GL_IMPLEMENTATION_COLOR_READ_FORMAT and GL_IMPLEMENTATION_COLOR_READ_TYPE.
     if ((format == gl.RGBA && type == gl.UNSIGNED_BYTE) || (format == implFormat && type == implType)) {
       wtu.glErrorShouldBe(
           gl, gl.NO_ERROR,
           "Should be able to read as " + wtu.glEnumToString(gl, format) +
           " / " + wtu.glEnumToString(gl, type));
     } else {
       wtu.glErrorShouldBe(
           gl, gl.INVALID_OPERATION,
           "Should not be able to read as " + wtu.glEnumToString(gl, format) +
           " / " + wtu.glEnumToString(gl, type));
     }
   }

   debug("");
   debug("check reading with lots of drawing");
   continueTestFunc = continueTestPart3;
   width = 1024;
   height = 1024;
   canvas.width = width;
   canvas.height = height;
   if (gl.getError() != gl.CONTEXT_LOST_WEBGL) {
     continueTestPart3();
   }
 }

 function continueTestPart3() {
   gl.viewport(0, 0, 1024, 1024);
   var program = wtu.setupTexturedQuad(gl);
   var loc = gl.getUniformLocation(program, "tex");
   gl.disable(gl.BLEND);
   gl.disable(gl.DEPTH_TEST);
   var colors = [[255, 0, 0, 255], [0, 255, 0, 255], [0, 0, 255, 255]];
   var textures = [];
   var results = [];
   for (var ii = 0; ii < colors.length; ++ii) {
     gl.activeTexture(gl.TEXTURE0 + ii);
     var tex = gl.createTexture();
     wtu.fillTexture(gl, tex, 1, 1, colors[ii]);
     textures.push(tex);
   }
   for (var ii = 0; ii < colors.length; ++ii) {
     for (var jj = 0; jj < 300 + ii + 1; ++jj) {
       gl.uniform1i(loc, jj % 3);
       gl.drawArrays(gl.TRIANGLES, 0, 6);
     }
     var buf = new Uint8Array(4);
     gl.readPixels(512, 512, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, buf);
     results.push(buf);
     for (var kk = 0; kk < 99; ++kk) {
       gl.uniform1i(loc, (jj + kk) % 3);
       gl.drawArrays(gl.TRIANGLES, 0, 6);
     }
   }
   for (var ii = 0; ii < colors.length; ++ii) {
     var buf = results[ii];
     var color = colors[ii];
     actual = [buf[0], buf[1], buf[2], buf[3]];
     expected = [color[0], color[1], color[2], color[3]];
     shouldBe("actual", "expected");
   }
   wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no GL errors");

   debug("");
   finishTest();
 }
 </script>
 </body>
 </html>
	<!--

	/*
	** Copyright (c) 2012 The Khronos Group Inc.
	**
	** Permission is hereby granted, free of charge, to any person obtaining a
	** copy of this software and/or associated documentation files (the
	** "Materials"), to deal in the Materials without restriction, including
	** without limitation the rights to use, copy, modify, merge, publish,
	** distribute, sublicense, and/or sell copies of the Materials, and to
	** permit persons to whom the Materials are furnished to do so, subject to
	** the following conditions:
	**
	** The above copyright notice and this permission notice shall be included
	** in all copies or substantial portions of the Materials.
	**
	** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
	** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
	** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
	** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
	*/

	-->

	<!DOCTYPE html>
	<html>
	<head>
	<meta charset="utf-8">
	<title>WebGL ReadPixels conformance test.</title>
	<link rel="stylesheet" href="../../resources/js-test-style.css"/>
	<script src="../../js/desktop-gl-constants.js"></script>
	<script src="../../js/js-test-pre.js"></script>
	<script src="../../js/webgl-test-utils.js"> </script>
	</head>
	<body>
	<canvas id="example" width="200" height="200" style="width: 20px; height: 20px"></canvas>
	<div id="description"></div>
	<div id="console"></div>
	<script>
	"use strict";
	description("Checks that ReadPixels works as expected.");

	var wtu = WebGLTestUtils;
	var canvas = document.getElementById("example");
	var gl = wtu.create3DContext(canvas);
	var contextVersion = wtu.getDefault3DContextVersion();

	var actual;
	var expected;
	var width = 2;
	var height = 2;
	var continueTestFunc = continueTestPart1;

	gl.clearColor(1, 1, 1, 1);
	gl.clear(gl.COLOR_BUFFER_BIT);

	// Resize the canvas to 2x2. This is an attempt to get stuff in the backbuffer.
	// that shouldn't be there.
	canvas.addEventListener("webglcontextlost", function(e) { e.preventDefault(); }, false);
	canvas.addEventListener("webglcontextrestored", continueTestAfterContextRestored, false);
	canvas.width = width;
	canvas.height = height;
	if (gl.getError() != gl.CONTEXT_LOST_WEBGL) {
	continueTestPart1();
	}

	function continueTestAfterContextRestored() {
	window.gl = wtu.create3DContext(canvas);
	var func = continueTestFunc;
	window.continueTestFunc = function() { testFailed("should not be here"); };
	func();
	}

	function continueTestPart1() {
	gl.clearColor(0.2, 0.6, 0.4, 1);
	gl.clear(gl.COLOR_BUFFER_BIT);

	var innerColor = [51, 153, 102, 255]; // (0.2, 0.6, 0.4, 1)
	var outerColor = [19, 72, 0, 198]; // Random color other than [0, 0, 0, 0]

	var tests = [
	{ msg: 'in range', checkColor: innerColor, x: 0, y: 0,
	oneColor: innerColor, oneX: 0, oneY: 0},
	{ msg: 'off top left', checkColor: outerColor, x: -1, y: -1,
	oneColor: innerColor, oneX: 1, oneY: 1},
	{ msg: 'off bottom right', checkColor: outerColor, x: 1, y: 1,
	oneColor: innerColor, oneX: 0, oneY: 0},
	{ msg: 'completely off top ', checkColor: outerColor, x: 0, y: -2,
	oneColor: outerColor, oneX: 0, oneY: 0},
	{ msg: 'completely off bottom', checkColor: outerColor, x: 0, y: 2,
	oneColor: outerColor, oneX: 0, oneY: 0},
	{ msg: 'completely off left', checkColor: outerColor, x: -2, y: 0,
	oneColor: outerColor, oneX: 0, oneY: 0},
	{ msg: 'completeley off right', checkColor: outerColor, x: 2, y: 0,
	oneColor: outerColor, oneX: 0, oneY: 0}
	];

	for (var tt = 0; tt < tests.length; ++tt) {
	var test = tests[tt];
	debug("");
	debug("checking: " + test.msg);
	checkBuffer(test.checkColor, test.x, test.y,
	test.oneColor, test.oneX, test.oneY);
	}

	wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no GL errors");

	function checkBuffer(checkColor, x, y, oneColor, oneX, oneY) {
	var buf = new Uint8Array(width * height * 4);
	// Initialize buf.
	for (var ii = 0; ii < width * height; ++ii) {
	buf[ii * 4] = outerColor[0];
	buf[ii * 4 + 1] = outerColor[1];
	buf[ii * 4 + 2] = outerColor[2];
	buf[ii * 4 + 3] = outerColor[3];
	}
	gl.readPixels(x, y, width, height, gl.RGBA, gl.UNSIGNED_BYTE, buf);
	for (var yy = 0; yy < height; ++yy) {
	for (var xx = 0; xx < width; ++xx) {
	var offset = (yy * width + xx) * 4;
	var expectedColors = (oneX == xx && oneY == yy) ? oneColor : checkColor;
	var mismatch = false;
	for (var cc = 0; cc < 4; ++cc) {
	var expectedColor = expectedColors[cc];
	var color = buf[offset + cc];
	var diff = Math.abs(expectedColor - color);
	if (diff >= 3) {
	mismatch = true;
	break;
	}
	}
	assertMsg(!mismatch,
	"color pixel at " + xx + ", " + yy + " should be about " + expectedColors +
	", was = " + [buf[offset], buf[offset + 1], buf[offset + 2], buf[offset + 3]]);
	}
	}
	}

	continueTestPart2();
	}

	function continueTestPart2() {
	var invalidFormat = [gl.DEPTH_COMPONENT, gl.DEPTH_STENCIL, desktopGL.R8, gl.RGBA4, gl.LUMINANCE, gl.LUMINANCE_ALPHA];
	if (contextVersion < 2) {
	// They are valid in WebGL 2 or higher
	invalidFormat = invalidFormat.concat([desktopGL.RED, desktopGL.RG_INTEGER, desktopGL.RGBA_INTEGER]);
	}

	var invalidTypeInfo = [
	{type: desktopGL.UNSIGNED_INT_24_8, dest: new Uint32Array(4)}
	];
	if (contextVersion < 2) {
	// They are valid in WebGL 2 or Higher
	invalidTypeInfo = invalidTypeInfo.concat([
	{type: gl.UNSIGNED_SHORT, dest: new Uint16Array(4)},
	{type: gl.SHORT, dest: new Int16Array(4)},
	{type: gl.BYTE, dest: new Int8Array(4)},
	{type: gl.UNSIGNED_INT, dest: new Uint32Array(4)},
	{type: desktopGL.UNSIGNED_INT_2_10_10_10_REV, dest: new Uint32Array(4)}
	]);
	}

	debug("");
	debug("check invalid format or type");
	for (var ff = 0; ff < invalidFormat.length; ++ff) {
	var format = invalidFormat[ff];
	var buf = new Uint8Array(4);
	gl.readPixels(0, 0, 1, 1, format, gl.UNSIGNED_BYTE, buf);
	wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "Should not be able to read as " + wtu.glEnumToString(gl, format));
	}

	for (var tt = 0; tt < invalidTypeInfo.length; ++tt) {
	var info = invalidTypeInfo[tt];
	var type = info.type;
	var dest = info.dest;
	gl.readPixels(0, 0, 1, 1, gl.RGBA, type, dest);
	wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "Should not be able to read as " + wtu.glEnumToString(gl, type));
	}

	var combinations = [
	{
	format: gl.RGBA,
	type: gl.UNSIGNED_BYTE,
	dest: new Uint8Array(4),
	},
	{
	format: gl.RGB,
	type: gl.UNSIGNED_BYTE,
	dest: new Uint8Array(3),
	},
	{
	format: gl.RGB,
	type: gl.UNSIGNED_SHORT_5_6_5,
	dest: new Uint8Array(3),
	},
	{
	format: gl.RGBA,
	type: gl.UNSIGNED_SHORT_5_5_5_1,
	dest: new Uint16Array(1),
	},
	{
	format: gl.RGBA,
	type: gl.UNSIGNED_SHORT_4_4_4_4,
	dest: new Uint16Array(1),
	},
	{
	format: gl.ALPHA,
	type: gl.UNSIGNED_BYTE,
	dest: new Uint8Array(1),
	}
	];
	if (contextVersion > 1) {
	combinations = combinations.concat([
	{
	format: gl.RED,
	type: gl.UNSIGNED_BYTE,
	dest: new Uint8Array(1),
	},
	{
	format: gl.RGBA_INTEGER,
	type: gl.UNSIGNED_INT,
	dest: new Uint32Array(4),
	},
	{
	format: gl.RGBA_INTEGER,
	type: gl.INT,
	dest: new Int32Array(4),
	}
	]);
	}

	debug("");
	debug("check invalid combinations of format/type");

	var implFormat = gl.getParameter(gl.IMPLEMENTATION_COLOR_READ_FORMAT);
	var implType = gl.getParameter(gl.IMPLEMENTATION_COLOR_READ_TYPE);

	for (var tt = 0; tt < combinations.length; ++ tt) {
	var info = combinations[tt];
	var format = info.format;
	var type = info.type;
	var dest = info.dest;
	gl.readPixels(0, 0, 1, 1, format, type, dest);
	// Only two format/type parameter pairs are accepted. GL_RGBA/GL_UNSIGNED_BYTE is always
	// accepted on default readbuffer. The other acceptable pair can be discovered by querying
	// GL_IMPLEMENTATION_COLOR_READ_FORMAT and GL_IMPLEMENTATION_COLOR_READ_TYPE.
	if ((format == gl.RGBA && type == gl.UNSIGNED_BYTE) \|\| (format == implFormat && type == implType)) {
	wtu.glErrorShouldBe(
	gl, gl.NO_ERROR,
	"Should be able to read as " + wtu.glEnumToString(gl, format) +
	" / " + wtu.glEnumToString(gl, type));
	} else {
	wtu.glErrorShouldBe(
	gl, gl.INVALID_OPERATION,
	"Should not be able to read as " + wtu.glEnumToString(gl, format) +
	" / " + wtu.glEnumToString(gl, type));
	}
	}

	debug("");
	debug("check reading with lots of drawing");
	continueTestFunc = continueTestPart3;
	width = 1024;
	height = 1024;
	canvas.width = width;
	canvas.height = height;
	if (gl.getError() != gl.CONTEXT_LOST_WEBGL) {
	continueTestPart3();
	}
	}

	function continueTestPart3() {
	gl.viewport(0, 0, 1024, 1024);
	var program = wtu.setupTexturedQuad(gl);
	var loc = gl.getUniformLocation(program, "tex");
	gl.disable(gl.BLEND);
	gl.disable(gl.DEPTH_TEST);
	var colors = [[255, 0, 0, 255], [0, 255, 0, 255], [0, 0, 255, 255]];
	var textures = [];
	var results = [];
	for (var ii = 0; ii < colors.length; ++ii) {
	gl.activeTexture(gl.TEXTURE0 + ii);
	var tex = gl.createTexture();
	wtu.fillTexture(gl, tex, 1, 1, colors[ii]);
	textures.push(tex);
	}
	for (var ii = 0; ii < colors.length; ++ii) {
	for (var jj = 0; jj < 300 + ii + 1; ++jj) {
	gl.uniform1i(loc, jj % 3);
	gl.drawArrays(gl.TRIANGLES, 0, 6);
	}
	var buf = new Uint8Array(4);
	gl.readPixels(512, 512, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, buf);
	results.push(buf);
	for (var kk = 0; kk < 99; ++kk) {
	gl.uniform1i(loc, (jj + kk) % 3);
	gl.drawArrays(gl.TRIANGLES, 0, 6);
	}
	}
	for (var ii = 0; ii < colors.length; ++ii) {
	var buf = results[ii];
	var color = colors[ii];
	actual = [buf[0], buf[1], buf[2], buf[3]];
	expected = [color[0], color[1], color[2], color[3]];
	shouldBe("actual", "expected");
	}
	wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no GL errors");

	debug("");
	finishTest();
	}
	</script>
	</body>
	</html>