From a115a655b26a04ab2ca29beb1649b12a9337ce14 Mon Sep 17 00:00:00 2001
From: Alexey Knyazev <3479527+lexaknyazev@users.noreply.github.com>
Date: Fri, 30 Jun 2023 00:00:00 +0000
Subject: [PATCH] Move texture extensions to draft; add tests

---
 .../extension.xml                             |   6 +-
 .../WEBGL_stencil_texturing/extension.xml     |  11 +-
 .../conformance/extensions/00_test_list.txt   |   1 +
 .../ext-texture-mirror-clamp-to-edge.html     | 217 ++++++++++++++
 .../conformance2/extensions/00_test_list.txt  |   1 +
 .../extensions/webgl-stencil-texturing.html   | 270 ++++++++++++++++++
 6 files changed, 498 insertions(+), 8 deletions(-)
 rename extensions/{proposals => }/EXT_texture_mirror_clamp_to_edge/extension.xml (96%)
 rename extensions/{proposals => }/WEBGL_stencil_texturing/extension.xml (90%)
 create mode 100644 sdk/tests/conformance/extensions/ext-texture-mirror-clamp-to-edge.html
 create mode 100644 sdk/tests/conformance2/extensions/webgl-stencil-texturing.html

diff --git a/extensions/proposals/EXT_texture_mirror_clamp_to_edge/extension.xml b/extensions/EXT_texture_mirror_clamp_to_edge/extension.xml
similarity index 96%
rename from extensions/proposals/EXT_texture_mirror_clamp_to_edge/extension.xml
rename to extensions/EXT_texture_mirror_clamp_to_edge/extension.xml
index 6e59a4aa8..3a32ad4f8 100644
--- a/extensions/proposals/EXT_texture_mirror_clamp_to_edge/extension.xml
+++ b/extensions/EXT_texture_mirror_clamp_to_edge/extension.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<proposal href="proposals/EXT_texture_mirror_clamp_to_edge/">
+<draft href="EXT_texture_mirror_clamp_to_edge/">
   <name>EXT_texture_mirror_clamp_to_edge</name>
 
   <contact> <a href="https://www.khronos.org/webgl/public-mailing-list/">WebGL
@@ -9,7 +9,7 @@
     <contributor>Members of the WebGL working group</contributor>
   </contributors>
 
-  <number>NN</number>
+  <number>62</number>
 
   <depends>
     <api version="1.0"/>
@@ -71,4 +71,4 @@ interface EXT_texture_mirror_clamp_to_edge {
       <change>Initial Draft.</change>
     </revision>
   </history>
-</proposal>
+</draft>
diff --git a/extensions/proposals/WEBGL_stencil_texturing/extension.xml b/extensions/WEBGL_stencil_texturing/extension.xml
similarity index 90%
rename from extensions/proposals/WEBGL_stencil_texturing/extension.xml
rename to extensions/WEBGL_stencil_texturing/extension.xml
index ebaf54c7b..3a6ca1c1c 100644
--- a/extensions/proposals/WEBGL_stencil_texturing/extension.xml
+++ b/extensions/WEBGL_stencil_texturing/extension.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<proposal href="proposals/WEBGL_stencil_texturing/">
+<draft href="WEBGL_stencil_texturing/">
   <name>WEBGL_stencil_texturing</name>
 
   <contact> <a href="https://www.khronos.org/webgl/public-mailing-list/">WebGL
@@ -9,7 +9,7 @@
     <contributor>Members of the WebGL working group</contributor>
   </contributors>
 
-  <number>NN</number>
+  <number>61</number>
 
   <depends>
     <api version="2.0"/>
@@ -25,6 +25,7 @@
 [Exposed=(Window,Worker), LegacyNoInterfaceObject]
 interface WEBGL_stencil_texturing {
     const GLenum DEPTH_STENCIL_TEXTURE_MODE_WEBGL = 0x90EA;
+    const GLenum STENCIL_INDEX_WEBGL              = 0x1901;
 };
   </idl>
 
@@ -34,7 +35,7 @@ interface WEBGL_stencil_texturing {
       <param name="pname" type="GLenum"/>
       <param name="param" type="GLfloat"/>
       A new enum <code>DEPTH_STENCIL_TEXTURE_MODE_WEBGL</code> is accepted as the <code>pname</code> parameter;
-      <code>param</code> must be <code>DEPTH_COMPONENT</code> (default) or <code>STENCIL_INDEX</code>.
+      <code>param</code> must be <code>DEPTH_COMPONENT</code> (default) or <code>STENCIL_INDEX_WEBGL</code>.
     </function>
 
     <function name="texParameteri" type="undefined">
@@ -42,7 +43,7 @@ interface WEBGL_stencil_texturing {
       <param name="pname" type="GLenum"/>
       <param name="param" type="GLint"/>
       A new enum <code>DEPTH_STENCIL_TEXTURE_MODE_WEBGL</code> is accepted as the <code>pname</code> parameter;
-      <code>param</code> must be <code>DEPTH_COMPONENT</code> (default) or <code>STENCIL_INDEX</code>.
+      <code>param</code> must be <code>DEPTH_COMPONENT</code> (default) or <code>STENCIL_INDEX_WEBGL</code>.
     </function>
 
     <function name="getTexParameter" type="any">
@@ -66,4 +67,4 @@ interface WEBGL_stencil_texturing {
       <change>Initial Draft.</change>
     </revision>
   </history>
-</proposal>
+</draft>
diff --git a/sdk/tests/conformance/extensions/00_test_list.txt b/sdk/tests/conformance/extensions/00_test_list.txt
index 4120f440e..e79aa2fb5 100644
--- a/sdk/tests/conformance/extensions/00_test_list.txt
+++ b/sdk/tests/conformance/extensions/00_test_list.txt
@@ -13,6 +13,7 @@
 --min-version 1.0.3 --max-version 1.9.9 ext-shader-texture-lod.html
 --min-version 1.0.3 --max-version 1.9.9 ext-sRGB.html
 --min-version 1.0.2 ext-texture-filter-anisotropic.html
+--min-version 1.0.4 ext-texture-mirror-clamp-to-edge.html
 --min-version 1.0.2 get-extension.html
 --min-version 1.0.4 khr-parallel-shader-compile.html
 --max-version 1.9.9 oes-standard-derivatives.html
diff --git a/sdk/tests/conformance/extensions/ext-texture-mirror-clamp-to-edge.html b/sdk/tests/conformance/extensions/ext-texture-mirror-clamp-to-edge.html
new file mode 100644
index 000000000..4e2f980b4
--- /dev/null
+++ b/sdk/tests/conformance/extensions/ext-texture-mirror-clamp-to-edge.html
@@ -0,0 +1,217 @@
+<!--
+Copyright (c) 2023 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 EXT_texture_mirror_clamp_to_edge 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>
+<canvas width="32" height="32" id="c"></canvas>
+<div id="description"></div>
+<div id="console"></div>
+<script>
+"use strict";
+description("This test verifies the functionality of the EXT_texture_mirror_clamp_to_edge extension, if it is available.");
+
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("c");
+const w = gl.drawingBufferWidth;
+const h = gl.drawingBufferHeight;
+var ext;
+var sampler;
+
+const pnames = ['TEXTURE_WRAP_S', 'TEXTURE_WRAP_T'];
+if (gl.TEXTURE_WRAP_R) {
+    pnames.push('TEXTURE_WRAP_R');
+}
+
+function runTestNoExtension() {
+    debug("");
+    debug("Check the texture parameter without the extension");
+
+    const tex = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+
+    const MIRROR_CLAMP_TO_EDGE_EXT = 0x8743;
+
+    for (const pname of pnames) {
+        gl.texParameteri(gl.TEXTURE_2D, gl[pname], MIRROR_CLAMP_TO_EDGE_EXT);
+        wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, `value unknown for ${pname} via texParameteri without enabling the extension`);
+        wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no more errors");
+        gl.texParameterf(gl.TEXTURE_2D, gl[pname], MIRROR_CLAMP_TO_EDGE_EXT);
+        wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, `value unknown for ${pname} via texParameterf without enabling the extension`);
+        wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no more errors");
+    }
+
+    if (!gl.createSampler) return;
+
+    const sampler = gl.createSampler();
+    for (const pname of pnames) {
+        gl.samplerParameteri(sampler, gl[pname], MIRROR_CLAMP_TO_EDGE_EXT);
+        wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, `value unknown for ${pname} via samplerParameteri without enabling the extension`);
+        wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no more errors");
+        gl.samplerParameterf(sampler, gl[pname], MIRROR_CLAMP_TO_EDGE_EXT);
+        wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, `value unknown for ${pname} via samplerParameterf without enabling the extension`);
+        wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no more errors");
+    }
+}
+
+function checkEnums() {
+    debug("");
+    debug("Check enums");
+    shouldBe("ext.MIRROR_CLAMP_TO_EDGE_EXT", "0x8743");
+}
+
+function checkQueries() {
+    debug("");
+    debug("Check texture and sampler state updates");
+
+    const tex = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+
+    for (const pname of pnames) {
+        gl.texParameteri(gl.TEXTURE_2D, gl[pname], ext.MIRROR_CLAMP_TO_EDGE_EXT);
+        wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors from texParameteri");
+        shouldBe(`gl.getTexParameter(gl.TEXTURE_2D, gl.${pname})`, "ext.MIRROR_CLAMP_TO_EDGE_EXT");
+        gl.texParameteri(gl.TEXTURE_2D, gl[pname], gl.REPEAT);
+
+        gl.texParameterf(gl.TEXTURE_2D, gl[pname], ext.MIRROR_CLAMP_TO_EDGE_EXT);
+        wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors from texParameterf");
+        shouldBe(`gl.getTexParameter(gl.TEXTURE_2D, gl.${pname})`, "ext.MIRROR_CLAMP_TO_EDGE_EXT");
+        gl.texParameterf(gl.TEXTURE_2D, gl[pname], gl.REPEAT);
+    }
+
+    if (!gl.createSampler) return;
+
+    sampler = gl.createSampler();
+    for (const pname of pnames) {
+        gl.samplerParameteri(sampler, gl[pname], ext.MIRROR_CLAMP_TO_EDGE_EXT);
+        wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors from samplerParameteri");
+        shouldBe(`gl.getSamplerParameter(sampler, gl.${pname})`, "ext.MIRROR_CLAMP_TO_EDGE_EXT");
+        gl.samplerParameteri(sampler, gl[pname], gl.REPEAT);
+
+        gl.samplerParameterf(sampler, gl[pname], ext.MIRROR_CLAMP_TO_EDGE_EXT);
+        wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors from samplerParameterf");
+        shouldBe(`gl.getSamplerParameter(sampler, gl.${pname})`, "ext.MIRROR_CLAMP_TO_EDGE_EXT");
+        gl.samplerParameterf(sampler, gl[pname], gl.REPEAT);
+    }
+}
+
+function checkSampling() {
+    debug("");
+    debug(`Check texture sampling with mirror-clamp-to-edge mode`);
+
+    wtu.setupUnitQuad(gl);
+    const vs = `precision highp float;
+        attribute vec4 vPosition;
+        varying vec2 texCoord;
+        void main() {
+            gl_Position = vec4(vPosition.xy, 0.0, 1.0);
+            texCoord = vPosition.xy * 2.0;
+        }`;
+    const program = wtu.setupProgram(gl, [vs, wtu.simpleTextureFragmentShader]);
+    gl.useProgram(program);
+
+    const black = [  0,   0,   0, 255];
+    const red   = [255,   0,   0, 255];
+    const green = [  0, 255,   0, 255];
+    const blue  = [  0,   0, 255, 255];
+    const data = new Uint8Array([...black, ...red, ...green, ...blue]);
+
+    function checkPixels() {
+        function checkPixel(x, y, color) {
+            const screen = (s, t) => s * (t * 0.5 + 0.5);
+            wtu.checkCanvasRect(gl, screen(w, x), screen(h, y), 1, 1, color,
+                                `(${x.toFixed(3)}, ${y.toFixed(3)}): ${color} `);
+        }
+        for (const signX of [+1, -1]) {
+            for (const signY of [+1, -1]) {
+                // This function expects screen-space coordinates
+                // normalized to [-1, +1]. The region from [0, 0]
+                // to [+1, +1] behaves like regular clamp-to-edge.
+                // Other three quadrants should be mirrored.
+                checkPixel(signX * 0.125, signY * 0.125, black);
+                checkPixel(signX * 0.375, signY * 0.125, red);
+                checkPixel(signX * 0.750, signY * 0.125, red);
+                checkPixel(signX * 0.125, signY * 0.375, green);
+                checkPixel(signX * 0.125, signY * 0.750, green);
+                checkPixel(signX * 0.375, signY * 0.375, blue);
+                checkPixel(signX * 0.750, signY * 0.375, blue);
+                checkPixel(signX * 0.375, signY * 0.750, blue);
+                checkPixel(signX * 0.750, signY * 0.750, blue);
+            }
+        }
+    }
+
+    const tex = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 2, 2, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, ext.MIRROR_CLAMP_TO_EDGE_EXT);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, ext.MIRROR_CLAMP_TO_EDGE_EXT);
+
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "texture created and configured");
+
+    wtu.drawUnitQuad(gl);
+    checkPixels();
+
+    if (!gl.createSampler) return;
+
+    debug("");
+    debug(`Check texture sampling with mirror-clamp-to-edge mode using a sampler object`);
+
+    const texWithSampler = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, texWithSampler);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 2, 2, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
+
+    sampler = gl.createSampler();
+    gl.bindSampler(0, sampler);
+    gl.samplerParameteri(sampler, gl.TEXTURE_WRAP_S, ext.MIRROR_CLAMP_TO_EDGE_EXT);
+    gl.samplerParameteri(sampler, gl.TEXTURE_WRAP_T, ext.MIRROR_CLAMP_TO_EDGE_EXT);
+    gl.samplerParameteri(sampler, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.samplerParameteri(sampler, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "texture created and sampler configured");
+
+    wtu.drawUnitQuad(gl);
+    checkPixels();
+}
+
+function runTest() {
+    if (!gl) {
+        testFailed("context does not exist");
+        return;
+    }
+    testPassed("context exists");
+
+    runTestNoExtension();
+
+    ext = gl.getExtension("EXT_texture_mirror_clamp_to_edge");
+    wtu.runExtensionSupportedTest(gl, "EXT_texture_mirror_clamp_to_edge", ext !== null);
+
+    if (ext !== null) {
+        checkEnums();
+        checkQueries();
+        checkSampling();
+    } else {
+        testPassed("No EXT_texture_mirror_clamp_to_edge support -- this is legal");
+    }
+}
+
+runTest();
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/sdk/tests/conformance2/extensions/00_test_list.txt b/sdk/tests/conformance2/extensions/00_test_list.txt
index 1641a9dec..fce7491e9 100644
--- a/sdk/tests/conformance2/extensions/00_test_list.txt
+++ b/sdk/tests/conformance2/extensions/00_test_list.txt
@@ -24,3 +24,4 @@ promoted-extensions-in-shaders.html
 --min-version 2.0.1 webgl-multi-draw-instanced-base-vertex-base-instance.html
 --min-version 2.0.1 webgl-provoking-vertex.html
 --min-version 2.0.1 webgl-shader-pixel-local-storage.html
+--min-version 2.0.1 webgl-stencil-texturing.html
diff --git a/sdk/tests/conformance2/extensions/webgl-stencil-texturing.html b/sdk/tests/conformance2/extensions/webgl-stencil-texturing.html
new file mode 100644
index 000000000..762453cc8
--- /dev/null
+++ b/sdk/tests/conformance2/extensions/webgl-stencil-texturing.html
@@ -0,0 +1,270 @@
+<!--
+Copyright (c) 2023 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 WEBGL_stencil_texturing 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 WEBGL_stencil_texturing extension, if it is available.");
+
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext(null, null, 2);
+var ext;
+
+function runTestNoExtension() {
+    debug("");
+    debug("Check the texture parameter without the extension");
+
+    const tex = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+
+    shouldBeNull("gl.getTexParameter(gl.TEXTURE_2D, 0x90EA /* DEPTH_STENCIL_TEXTURE_MODE_WEBGL */)");
+    wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "parameter unknown without enabling the extension");
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no more errors");
+
+    gl.texParameteri(gl.TEXTURE_2D, 0x90EA /* DEPTH_STENCIL_TEXTURE_MODE_WEBGL */, gl.DEPTH_COMPONENT);
+    wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "parameter unknown for texParameteri without enabling the extension");
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no more errors");
+
+    gl.texParameterf(gl.TEXTURE_2D, 0x90EA /* DEPTH_STENCIL_TEXTURE_MODE_WEBGL */, gl.DEPTH_COMPONENT);
+    wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "parameter unknown for texParameterf without enabling the extension");
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no more errors");
+
+    const sampler = gl.createSampler();
+    gl.samplerParameteri(sampler, 0x90EA /* DEPTH_STENCIL_TEXTURE_MODE_WEBGL */, gl.DEPTH_COMPONENT);
+    wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "parameter unknown for samplerParameteri");
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no more errors");
+    gl.samplerParameterf(sampler, 0x90EA /* DEPTH_STENCIL_TEXTURE_MODE_WEBGL */, gl.DEPTH_COMPONENT);
+    wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "parameter unknown for samplerParameterf");
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no more errors");
+}
+
+function checkEnums() {
+    debug("");
+    debug("Check enums");
+    shouldBe("ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL", "0x90EA");
+    shouldBe("ext.STENCIL_INDEX_WEBGL",              "0x1901");
+}
+
+function checkQueries() {
+    const tex = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+
+    debug("");
+    debug("Check default texture state");
+    shouldBe('gl.getTexParameter(gl.TEXTURE_2D, ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL)', 'gl.DEPTH_COMPONENT');
+    debug("");
+    debug("Check texture state updates using texParameteri");
+    gl.texParameteri(gl.TEXTURE_2D, ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL, ext.STENCIL_INDEX_WEBGL);
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors");
+    shouldBe('gl.getTexParameter(gl.TEXTURE_2D, ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL)', 'ext.STENCIL_INDEX_WEBGL');
+    gl.texParameteri(gl.TEXTURE_2D, ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL, gl.DEPTH_COMPONENT);
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors");
+    shouldBe('gl.getTexParameter(gl.TEXTURE_2D, ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL)', 'gl.DEPTH_COMPONENT');
+    gl.texParameteri(gl.TEXTURE_2D, ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL, 0);
+    wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "invalid depth stencil mode value rejected by texParameteri");
+    shouldBe('gl.getTexParameter(gl.TEXTURE_2D, ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL)', 'gl.DEPTH_COMPONENT');
+    debug("");
+    debug("Check texture state updates using texParameterf");
+    gl.texParameterf(gl.TEXTURE_2D, ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL, ext.STENCIL_INDEX_WEBGL);
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors");
+    shouldBe('gl.getTexParameter(gl.TEXTURE_2D, ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL)', 'ext.STENCIL_INDEX_WEBGL');
+    gl.texParameterf(gl.TEXTURE_2D, ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL, gl.DEPTH_COMPONENT);
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors");
+    shouldBe('gl.getTexParameter(gl.TEXTURE_2D, ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL)', 'gl.DEPTH_COMPONENT');
+    gl.texParameterf(gl.TEXTURE_2D, ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL, 0);
+    wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "invalid depth stencil mode value rejected by texParameterf");
+    shouldBe('gl.getTexParameter(gl.TEXTURE_2D, ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL)', 'gl.DEPTH_COMPONENT');
+
+    debug("");
+    debug("Check that depth stencil texture mode is not accepted as a sampler state");
+    const sampler = gl.createSampler();
+    gl.samplerParameteri(sampler, ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL, gl.DEPTH_COMPONENT);
+    wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "parameter unknown for samplerParameteri");
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no more errors");
+    gl.samplerParameterf(sampler, ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL, gl.DEPTH_COMPONENT);
+    wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "parameter unknown for samplerParameterf");
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no more errors");
+}
+
+function checkSampling() {
+    const formats = [
+        {name: "DEPTH_COMPONENT16", internalFormat: gl.DEPTH_COMPONENT16,
+         format: gl.DEPTH_COMPONENT, type: gl.UNSIGNED_SHORT},
+        {name: "DEPTH_COMPONENT24", internalFormat: gl.DEPTH_COMPONENT24,
+         format: gl.DEPTH_COMPONENT, type: gl.UNSIGNED_INT},
+        {name: "DEPTH_COMPONENT32F", internalFormat: gl.DEPTH_COMPONENT32F,
+         format: gl.DEPTH_COMPONENT, type: gl.FLOAT},
+        {name: "DEPTH24_STENCIL8", internalFormat: gl.DEPTH24_STENCIL8,
+         format: gl.DEPTH_STENCIL, type: gl.UNSIGNED_INT_24_8},
+        {name: "DEPTH32F_STENCIL8", internalFormat: gl.DEPTH32F_STENCIL8,
+         format: gl.DEPTH_STENCIL, type: gl.FLOAT_32_UNSIGNED_INT_24_8_REV}
+    ];
+
+    gl.enable(gl.DEPTH_TEST);
+    gl.enable(gl.STENCIL_TEST);
+    gl.stencilFunc(gl.ALWAYS, 170, 0xFF);
+    gl.stencilOp(gl.REPLACE, gl.REPLACE, gl.REPLACE);
+
+    wtu.setupUnitQuad(gl);
+
+    const drawProgram = wtu.setupProgram(gl, [wtu.simpleVertexShader,
+                                          wtu.simpleColorFragmentShader]);
+
+    const readDepthProgram = wtu.setupProgram(gl, [wtu.simpleTextureVertexShaderESSL300,
+                                                   wtu.simpleTextureFragmentShaderESSL300]);
+
+    const readStencilShader = `#version 300 es
+        precision highp float;
+        uniform highp usampler2D tex;
+        in vec2 texCoord;
+        out vec4 out_color;
+        void main() {
+            out_color = vec4(texture(tex, texCoord)) / 255.0;
+        }`;
+    const readStencilProgram = wtu.setupProgram(gl, [wtu.simpleTextureVertexShaderESSL300,
+                                                     readStencilShader]);
+
+    for (const format of formats) {
+        debug("");
+        debug(`Testing depth stencil texture modes with ${format.name}`);
+        const fbo = gl.createFramebuffer();
+        gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
+
+        const rbo = gl.createRenderbuffer();
+        gl.bindRenderbuffer(gl.RENDERBUFFER, rbo);
+        gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA8, 1, 1);
+        gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rbo);
+
+        const tex = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.texImage2D(gl.TEXTURE_2D, 0, format.internalFormat, 1, 1, 0, format.format, format.type, null);
+        wtu.glErrorShouldBe(gl, gl.NO_ERROR, "texture created");
+
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.TEXTURE_2D, tex, 0);
+        if (format.format == gl.DEPTH_STENCIL) {
+            gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.TEXTURE_2D, tex, 0);
+        }
+        wtu.framebufferStatusShouldBe(gl, gl.FRAMEBUFFER, gl.FRAMEBUFFER_COMPLETE);
+
+        gl.clear(gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
+        gl.useProgram(drawProgram);
+        wtu.drawUnitQuad(gl);
+        wtu.glErrorShouldBe(gl, gl.NO_ERROR, "no errors after drawing to the depth or depth stencil texture");
+
+        // Detach the depth or depth stencil texture to avoid feedback loop
+        gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, null);
+        wtu.framebufferStatusShouldBe(gl, gl.FRAMEBUFFER, gl.FRAMEBUFFER_COMPLETE);
+
+        const magFilters = ['NEAREST', 'LINEAR'];
+
+        const minFilters = [
+            'NEAREST',
+            'LINEAR',
+            'NEAREST_MIPMAP_NEAREST',
+            'LINEAR_MIPMAP_NEAREST',
+            'NEAREST_MIPMAP_LINEAR',
+            'LINEAR_MIPMAP_LINEAR'
+        ];
+
+        const modes = [
+            [gl.DEPTH_COMPONENT, 'DEPTH_COMPONENT'],
+            [ext.STENCIL_INDEX_WEBGL, 'STENCIL_INDEX_WEBGL']
+        ];
+
+        const programs = [
+            [readDepthProgram, 'depth'],
+            [readStencilProgram, 'stencil']
+        ];
+
+        function validFilters(magFilter, minFilter) {
+            return magFilter == gl.NEAREST &&
+                   (minFilter == gl.NEAREST || minFilter == gl.NEAREST_MIPMAP_NEAREST);
+        }
+
+        for (const program of programs) {
+            gl.useProgram(program[0]);
+            for (const mode of modes) {
+                gl.texParameteri(gl.TEXTURE_2D, ext.DEPTH_STENCIL_TEXTURE_MODE_WEBGL, mode[0]);
+                for (const magFilter of magFilters) {
+                    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl[magFilter]);
+                    for (const minFilter of minFilters) {
+                        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl[minFilter]);
+                        debug(`Program: ${program[1]}, mode: ${mode[1]}, mag: ${magFilter}, min: ${minFilter}`);
+
+                        gl.clear(gl.COLOR_BUFFER_BIT);
+                        wtu.drawUnitQuad(gl);
+
+                        if (format.format == gl.DEPTH_COMPONENT || mode[0] == gl.DEPTH_COMPONENT) {
+                            if (program[1] == 'depth') {
+                                wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors");
+                                if (validFilters(gl[magFilter], gl[minFilter])) {
+                                    wtu.checkCanvasRect(gl, 0, 0, 1, 1, [128, 0, 0, 255], "sampling depth from complete texture", 1);
+                                } else {
+                                    wtu.checkCanvasRect(gl, 0, 0, 1, 1, [0, 0, 0, 255], "sampling depth from incomplete texture", 1);
+                                }
+                            } else {
+                                wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "sampling depth using incompatible program");
+                            }
+                        } else {
+                            if (program[1] == 'stencil') {
+                                wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors");
+                                if (validFilters(gl[magFilter], gl[minFilter])) {
+                                    wtu.checkCanvasRect(gl, 0, 0, 1, 1, [170, 0, 0, 1], "sampling stencil from complete texture", 1);
+                                } else {
+                                    wtu.checkCanvasRect(gl, 0, 0, 1, 1, [0, 0, 0, 255], "sampling stencil from incomplete texture", 1);
+                                }
+                            } else {
+                                wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "sampling stencil using incompatible program");
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+function runTest() {
+    if (!gl) {
+        testFailed("context does not exist");
+        return;
+    }
+    testPassed("context exists");
+
+    runTestNoExtension();
+
+    ext = gl.getExtension("WEBGL_stencil_texturing");
+    wtu.runExtensionSupportedTest(gl, "WEBGL_stencil_texturing", ext !== null);
+
+    if (ext !== null) {
+        checkEnums();
+        checkQueries();
+        checkSampling();
+    } else {
+        testPassed("No WEBGL_stencil_texturing support -- this is legal");
+    }
+}
+
+runTest();
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>