From c20fccbf31566b0b5e2c0ca363ccfa4b9e8e483f 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 renderbuffer format extensions to draft; add tests

---
 .../EXT_render_snorm/extension.xml            |   8 +-
 .../extension.xml                             |  10 +-
 .../conformance2/extensions/00_test_list.txt  |   2 +
 .../extensions/ext-render-snorm.html          | 201 ++++++++++++++
 .../webgl-render-shared-exponent.html         | 251 ++++++++++++++++++
 5 files changed, 465 insertions(+), 7 deletions(-)
 rename extensions/{proposals => }/EXT_render_snorm/extension.xml (89%)
 rename extensions/{proposals => }/WEBGL_render_shared_exponent/extension.xml (75%)
 create mode 100644 sdk/tests/conformance2/extensions/ext-render-snorm.html
 create mode 100644 sdk/tests/conformance2/extensions/webgl-render-shared-exponent.html

diff --git a/extensions/proposals/EXT_render_snorm/extension.xml b/extensions/EXT_render_snorm/extension.xml
similarity index 89%
rename from extensions/proposals/EXT_render_snorm/extension.xml
rename to extensions/EXT_render_snorm/extension.xml
index 9ca4a5932..820d45375 100644
--- a/extensions/proposals/EXT_render_snorm/extension.xml
+++ b/extensions/EXT_render_snorm/extension.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<proposal href="proposals/EXT_render_snorm/">
+<draft href="EXT_render_snorm/">
   <name>EXT_render_snorm</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>59</number>
 
   <depends>
     <api version="2.0"/>
@@ -30,7 +30,7 @@
         </ul>
       </feature>
       <feature>
-        When <a href="../../EXT_texture_norm16/">EXT_texture_norm16</a> is enabled, the
+        When <a href="../EXT_texture_norm16/">EXT_texture_norm16</a> is enabled, the
         following signed normalized internal formats also become <em>color-renderable</em>:
         <ul>
           <li><code>R16_SNORM_EXT</code></li>
@@ -52,4 +52,4 @@ interface EXT_render_snorm {
       <change>Initial Draft.</change>
     </revision>
   </history>
-</proposal>
+</draft>
diff --git a/extensions/proposals/WEBGL_render_shared_exponent/extension.xml b/extensions/WEBGL_render_shared_exponent/extension.xml
similarity index 75%
rename from extensions/proposals/WEBGL_render_shared_exponent/extension.xml
rename to extensions/WEBGL_render_shared_exponent/extension.xml
index ac8345af3..b946b83c6 100644
--- a/extensions/proposals/WEBGL_render_shared_exponent/extension.xml
+++ b/extensions/WEBGL_render_shared_exponent/extension.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<proposal href="proposals/WEBGL_render_shared_exponent/">
+<draft href="WEBGL_render_shared_exponent/">
   <name>WEBGL_render_shared_exponent</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>60</number>
 
   <depends>
     <api version="2.0"/>
@@ -18,6 +18,10 @@
   <overview>
     <mirrors href="https://www.khronos.org/registry/OpenGL/extensions/QCOM/QCOM_render_shared_exponent.txt"
              name="QCOM_render_shared_exponent">
+      <addendum>
+        Clearing or drawing to a shared exponent color buffer will generate <code>INVALID_OPERATION</code>
+        if the associated color write mask has different values for red, green, and blue channels.
+      </addendum>
     </mirrors>
 
     <features>
@@ -38,4 +42,4 @@ interface WEBGL_render_shared_exponent {
       <change>Initial Draft.</change>
     </revision>
   </history>
-</proposal>
+</draft>
diff --git a/sdk/tests/conformance2/extensions/00_test_list.txt b/sdk/tests/conformance2/extensions/00_test_list.txt
index 1641a9dec..edadde642 100644
--- a/sdk/tests/conformance2/extensions/00_test_list.txt
+++ b/sdk/tests/conformance2/extensions/00_test_list.txt
@@ -2,6 +2,7 @@ ext-color-buffer-float.html
 --min-version 2.0.1 ext-color-buffer-half-float.html
 --min-version 2.0.1 ext-conservative-depth.html
 ext-disjoint-timer-query-webgl2.html
+--min-version 2.0.1 ext-render-snorm.html
 --min-version 2.0.1 ext-texture-filter-anisotropic.html
 --min-version 2.0.1 ext-texture-norm16.html
 promoted-extensions.html
@@ -23,4 +24,5 @@ promoted-extensions-in-shaders.html
 --min-version 2.0.1 webgl-clip-cull-distance.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-render-shared-exponent.html
 --min-version 2.0.1 webgl-shader-pixel-local-storage.html
diff --git a/sdk/tests/conformance2/extensions/ext-render-snorm.html b/sdk/tests/conformance2/extensions/ext-render-snorm.html
new file mode 100644
index 000000000..723e76277
--- /dev/null
+++ b/sdk/tests/conformance2/extensions/ext-render-snorm.html
@@ -0,0 +1,201 @@
+<!--
+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_render_snorm 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 EXT_render_snorm extension, if it is available.");
+
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext(null, null, 2);
+var ext;
+
+function createTypedArray(type) {
+    switch (type) {
+        case gl.BYTE:
+            return new Int8Array(4);
+        case gl.UNSIGNED_BYTE:
+            return new Uint8Array(4);
+        case gl.SHORT:
+            return new Int16Array(4);
+        case gl.UNSIGNED_SHORT:
+            return new Uint16Array(4);
+        default:
+            return null;
+    }
+}
+
+function drawTest(config) {
+    wtu.drawUnitQuad(gl);
+
+    const implementationType = gl.getParameter(gl.IMPLEMENTATION_COLOR_READ_TYPE);
+    const implementationFormat = gl.getParameter(gl.IMPLEMENTATION_COLOR_READ_FORMAT);
+
+    // Support for reading signed data with unsigned read type is not required
+    // but implementations may allow such conversions. Do not expect the error
+    // when the type matches the buffer type or when it's explicitly supported.
+    for (const type of [gl.BYTE, gl.UNSIGNED_BYTE, gl.SHORT, gl.UNSIGNED_SHORT]) {
+        if (type == config.type) continue;
+        if (implementationFormat != gl.RGBA || implementationType != type) {
+            gl.readPixels(0, 0, 1, 1, gl.RGBA, type, createTypedArray(type));
+            wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "reading with unsupported type fails");
+        }
+    }
+
+    const defaultPixel = createTypedArray(config.type);
+    wtu.checkCanvasRect(gl, 0, 0, 1, 1, config.color,
+                        "reading with the RGBA format and matching type", 1,
+                        defaultPixel,
+                        config.type, gl.RGBA);
+
+    if (implementationFormat == config.format && implementationType == config.type) {
+        const implementationPixel = createTypedArray(implementationType);
+        const color = [config.color[0]];
+        if (config.format != gl.RED) color.push(config.color[1]);
+        if (config.format == gl.RGBA) color.push(config.color[2], config.color[3]);
+        wtu.checkCanvasRect(gl, 0, 0, 1, 1, color,
+                            "reading with the exact format/type", 1,
+                            implementationPixel,
+                            implementationType, implementationFormat);
+    }
+}
+
+function renderbufferTest(config, isSupported) {
+    debug("");
+    debug(`${config.name} renderbuffer: ` +
+          `${!isSupported || !config.color ? "NOT " : ""}supported`);
+
+    const rbo = gl.createRenderbuffer();
+    gl.bindRenderbuffer(gl.RENDERBUFFER, rbo);
+    gl.renderbufferStorage(gl.RENDERBUFFER, config.internalFormat, 1, 1);
+    if (!isSupported || !config.color) {
+        wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "renderbuffer allocation failed");
+        return;
+    }
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "renderbuffer allocation succeeded");
+
+    const fbo = gl.createFramebuffer();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
+    gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rbo);
+
+    wtu.framebufferStatusShouldBe(gl, gl.FRAMEBUFFER, gl.FRAMEBUFFER_COMPLETE);
+
+    drawTest(config);
+}
+
+function textureTest(config, isRenderable, isTexturable) {
+    debug("");
+    debug(`${config.name} texture: ` +
+          `${!isRenderable || !config.color ? "NOT " : ""}renderable, ` +
+          `${!isTexturable ? "NOT " : ""}texturable`);
+
+    const tex = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.texImage2D(gl.TEXTURE_2D, 0, config.internalFormat, 1, 1, 0, config.format, config.type, null);
+    if (!isTexturable) {
+        wtu.glErrorShouldBe(gl,
+                            [gl.INVALID_ENUM, gl.INVALID_VALUE, gl.INVALID_OPERATION],
+                            "texture allocation failed");
+        return;
+    }
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "texture allocation succeeded");
+
+    const fbo = gl.createFramebuffer();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0);
+
+    if (!isRenderable || !config.color) {
+        wtu.framebufferStatusShouldBe(gl, gl.FRAMEBUFFER, gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT);
+        return;
+    }
+    wtu.framebufferStatusShouldBe(gl, gl.FRAMEBUFFER, gl.FRAMEBUFFER_COMPLETE);
+
+    drawTest(config);
+}
+
+function formatTest(isSnormEnabled, isNorm16Enabled) {
+    const program = wtu.setupProgram(gl, [wtu.simpleVertexShader,
+                                          wtu.simpleColorFragmentShader]);
+    gl.useProgram(program);
+    gl.uniform4f(gl.getUniformLocation(program, "u_color"), -0.0625, -0.125, -0.25, -0.5);
+
+    wtu.setupUnitQuad(gl);
+
+    const configs8 = [
+        {name: "R8_SNORM",    format: gl.RED,  type: gl.BYTE, internalFormat: gl.R8_SNORM,    color: [-8,   0,   0, 127]},
+        {name: "RG8_SNORM",   format: gl.RG,   type: gl.BYTE, internalFormat: gl.RG8_SNORM,   color: [-8, -16,   0, 127]},
+        {name: "RGB8_SNORM",  format: gl.RGB,  type: gl.BYTE, internalFormat: gl.RGB8_SNORM,  color: null},
+        {name: "RGBA8_SNORM", format: gl.RGBA, type: gl.BYTE, internalFormat: gl.RGBA8_SNORM, color: [-8, -16, -32, -64]}
+    ];
+
+    const configs16 = [
+        {name: "R16_SNORM",    format: gl.RED,  type: gl.SHORT, internalFormat: 0x8F98 /* R16_SNORM_EXT */,    color: [-2048,   0,       0,  32767]},
+        {name: "RG16_SNORM",   format: gl.RG,   type: gl.SHORT, internalFormat: 0x8F99 /* RG16_SNORM_EXT */,   color: [-2048, -4096,     0,  32767]},
+        {name: "RGB16_SNORM",  format: gl.RGB,  type: gl.SHORT, internalFormat: 0x8F9A /* RGB16_SNORM_EXT */,  color: null},
+        {name: "RGBA16_SNORM", format: gl.RGBA, type: gl.SHORT, internalFormat: 0x8F9B /* RGBA16_SNORM_EXT */, color: [-2048, -4096, -8192, -16384]}
+    ];
+
+    for (const config of configs8) {
+        renderbufferTest(config, isSnormEnabled);
+        textureTest(config, isSnormEnabled, true);
+    }
+
+    for (const config of configs16) {
+        renderbufferTest(config, isSnormEnabled && isNorm16Enabled);
+        textureTest(config, isSnormEnabled && isNorm16Enabled, isNorm16Enabled);
+    }
+}
+
+function runTest() {
+    if (!gl) {
+        testFailed("context does not exist");
+        return;
+    }
+
+    testPassed("context exists");
+
+    debug("");
+    debug("Testing signed normalized formats with EXT_render_snorm disabled");
+    formatTest(false, false);
+
+    ext = gl.getExtension("EXT_render_snorm");
+    wtu.runExtensionSupportedTest(gl, "EXT_render_snorm", ext !== null);
+
+    if (ext !== null) {
+        debug("");
+        debug("Testing signed normalized formats with only EXT_render_snorm enabled");
+        formatTest(true, false);
+
+        if (gl.getExtension("EXT_texture_norm16")) {
+            debug("");
+            debug("Testing signed normalized formats with EXT_render_snorm and EXT_texture_norm16 enabled");
+            formatTest(true, true);
+        }
+    } else {
+        testPassed("No EXT_render_snorm 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/webgl-render-shared-exponent.html b/sdk/tests/conformance2/extensions/webgl-render-shared-exponent.html
new file mode 100644
index 000000000..11d505fcc
--- /dev/null
+++ b/sdk/tests/conformance2/extensions/webgl-render-shared-exponent.html
@@ -0,0 +1,251 @@
+<!--
+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_render_shared_exponent 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_render_shared_exponent extension, if it is available.");
+
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext(null, null, 2);
+var ext;
+const color = [64.0, 32.0, 16.0, 1.0];
+
+function drawTest() {
+    wtu.clearAndDrawUnitQuad(gl);
+
+    wtu.checkCanvasRect(gl, 0, 0, 1, 1, color,
+                        "reading with the RGBA format and FLOAT type", 1,
+                        new Float32Array(4), gl.FLOAT, gl.RGBA);
+
+    const implementationType = gl.getParameter(gl.IMPLEMENTATION_COLOR_READ_TYPE);
+    const implementationFormat = gl.getParameter(gl.IMPLEMENTATION_COLOR_READ_FORMAT);
+    if (implementationFormat == gl.RGB && implementationType == gl.UNSIGNED_INT_5_9_9_9_REV) {
+        // Shared exponent value may be implementation
+        // specific, so compare decoded values.
+        const value = new Uint32Array(1);
+        gl.readPixels(0, 0, 1, 1, gl.RGB, gl.UNSIGNED_INT_5_9_9_9_REV, value);
+        wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+
+        let r = (value >>  0) & 0x1FF;
+        let g = (value >>  9) & 0x1FF;
+        let b = (value >> 18) & 0x1FF;
+        let e = (value >> 27) & 0x01F;
+        debug(`Raw value: 0x${value[0].toString(16).toUpperCase()}, ` +
+              `Raw components: R = ${r}, G = ${g}, B = ${b}, E = ${e}`);
+
+        e = Math.pow(2, e - 24);
+        r *= e;
+        g *= e;
+        b *= e;
+        debug(`Decoded color: (${r}, ${g}, ${b})`);
+
+        if (r == color[0] && g == color[1] && b == color[2]) {
+            testPassed("reading with the exact format/type");
+        } else {
+            testFailed("reading with the exact format/type");
+        }
+    }
+}
+
+function renderbufferTest(isSupported) {
+    debug("");
+    debug(`RGB9_E5 renderbuffer: ` +
+          `${!isSupported ? "NOT " : ""}supported`);
+
+    const rbo = gl.createRenderbuffer();
+    gl.bindRenderbuffer(gl.RENDERBUFFER, rbo);
+    gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGB9_E5, 1, 1);
+    if (!isSupported) {
+        wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "renderbuffer allocation failed");
+        return;
+    }
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "renderbuffer allocation succeeded");
+
+    const fbo = gl.createFramebuffer();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
+    gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rbo);
+
+    wtu.framebufferStatusShouldBe(gl, gl.FRAMEBUFFER, gl.FRAMEBUFFER_COMPLETE);
+
+    drawTest();
+}
+
+function textureTest(isRenderable) {
+    debug("");
+    debug(`RGB9_E5 texture: ` +
+          `${!isRenderable ? "NOT " : ""}renderable`);
+
+    const tex = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB9_E5, 1, 1, 0, gl.RGB, gl.UNSIGNED_INT_5_9_9_9_REV, null);
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "texture allocation succeeded");
+
+    const fbo = gl.createFramebuffer();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0);
+
+    if (!isRenderable) {
+        wtu.framebufferStatusShouldBe(gl, gl.FRAMEBUFFER, gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT);
+        return;
+    }
+    wtu.framebufferStatusShouldBe(gl, gl.FRAMEBUFFER, gl.FRAMEBUFFER_COMPLETE);
+
+    drawTest();
+}
+
+function formatTest(isEnabled) {
+    const program = wtu.setupProgram(gl, [wtu.simpleVertexShader,
+                                          wtu.simpleColorFragmentShader]);
+    gl.useProgram(program);
+    gl.uniform4fv(gl.getUniformLocation(program, "u_color"), color);
+
+    wtu.setupUnitQuad(gl);
+
+    renderbufferTest(isEnabled);
+    textureTest(isEnabled);
+}
+
+function colorMaskTest() {
+    debug("");
+    debug("Test color write masks with shared exponent color buffers");
+
+    const fs = `#version 300 es
+        precision highp float;
+        layout(location = 0) out vec4 color0;
+        layout(location = 1) out vec4 color1;
+        void main() {
+            color0 = vec4(1.0, 0.0, 0.0, 1.0);
+            color1 = vec4(0.0, 1.0, 0.0, 1.0);
+        }`;
+    const program = wtu.setupProgram(gl, [wtu.simpleVertexShaderESSL300, fs]);
+    gl.useProgram(program);
+
+    const fbo = gl.createFramebuffer();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
+
+    const rb0 = gl.createRenderbuffer();
+    gl.bindRenderbuffer(gl.RENDERBUFFER, rb0);
+    gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGB9_E5, 4, 4);
+    gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rb0);
+
+    const rb1 = gl.createRenderbuffer();
+    gl.bindRenderbuffer(gl.RENDERBUFFER, rb1);
+    gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA8, 4, 4);
+    gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.RENDERBUFFER, rb1);
+
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+    wtu.framebufferStatusShouldBe(gl, gl.FRAMEBUFFER, gl.FRAMEBUFFER_COMPLETE);
+
+    const clearValue = new Float32Array(4);
+    const dbiExt = gl.getExtension("OES_draw_buffers_indexed");
+
+    function expectError(enabled, effectiveMask, operation) {
+        if (!enabled ||
+            effectiveMask == 0x0 /* 0000 */ ||
+            effectiveMask == 0x8 /* 000A */ ||
+            effectiveMask == 0x7 /* RGB0 */ ||
+            effectiveMask == 0xF /* RGBA */ ) {
+            wtu.glErrorShouldBe(gl, gl.NO_ERROR, operation);
+        } else {
+            wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, operation);
+        }
+    }
+
+    function runOps(enabled, mask0) {
+        wtu.drawUnitQuad(gl);
+        expectError(enabled, mask0, "draw");
+
+        gl.clear(gl.COLOR_BUFFER_BIT);
+        expectError(enabled, mask0, "clear");
+
+        gl.clearBufferfv(gl.COLOR, 0, clearValue);
+        expectError(enabled, mask0, "clearBufferfv(RGB9_E5)");
+        gl.clearBufferfv(gl.COLOR, 1, clearValue);
+        wtu.glErrorShouldBe(gl, gl.NO_ERROR, "clearBufferfv(RGBA8)");
+    }
+
+    for (let mask = 0; mask < 16; mask++) {
+        for (const enabled of [false, true]) {
+            debug("");
+            debug(`Setting common color mask ` +
+                  `${mask & 1 ? "R" : "0"}` +
+                  `${mask & 2 ? "G" : "0"}` +
+                  `${mask & 4 ? "B" : "0"}` +
+                  `${mask & 8 ? "A" : "0"}` +
+                  " with RGB9_E5 attachment " +
+                  (enabled ? "enabled" : "disabled"));
+            gl.colorMask(mask & 1, mask & 2, mask & 4, mask & 8);
+            gl.drawBuffers([enabled ? gl.COLOR_ATTACHMENT0 : gl.NONE,
+                            gl.COLOR_ATTACHMENT1]);
+
+            runOps(enabled, mask);
+
+            if (dbiExt) {
+                debug("Setting incompatible color mask on unused draw buffer")
+                dbiExt.colorMaskiOES(2, true, false, false, false);
+                runOps(enabled, mask); // common mask remains on draw buffer 0
+
+                debug("Setting incompatible color mask on RGBA8 draw buffer")
+                dbiExt.colorMaskiOES(1, true, false, false, false);
+                runOps(enabled, mask); // common mask remains on draw buffer 0
+
+                debug("Setting incompatible color mask on RGB9_E5 draw buffer")
+                dbiExt.colorMaskiOES(0, true, false, false, false);
+                runOps(enabled, 1); // overridden
+
+                debug("Setting compatible color mask on RGB9_E5 draw buffer")
+                dbiExt.colorMaskiOES(0, true, true, true, false);
+                runOps(enabled, 7); // overridden
+            }
+        }
+    }
+}
+
+function runTest() {
+    if (!gl) {
+        testFailed("context does not exist");
+        return;
+    }
+    testPassed("context exists");
+
+    debug("");
+    debug("Testing shared exponent rendering with extension disabled");
+    formatTest(false);
+
+    ext = gl.getExtension("WEBGL_render_shared_exponent");
+    wtu.runExtensionSupportedTest(gl, "WEBGL_render_shared_exponent", ext !== null);
+
+    if (ext !== null) {
+        debug("");
+        debug("Testing shared exponent rendering with extension enabled");
+        formatTest(true);
+        colorMaskTest();
+    } else {
+        testPassed("No WEBGL_render_shared_exponent support -- this is legal");
+    }
+}
+
+runTest();
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>