From 2d0e7f8799eb590f86e2d5f2fb17b1189c8f08d2 Mon Sep 17 00:00:00 2001
From: Kelsey Gilbert <kelsey.gilbert@mozilla.com>
Date: Wed, 24 Jul 2024 17:54:20 -0700
Subject: [PATCH] Tolerate throws in wasm/* tests, add 2gb-in-4gb variants.
 (#3665)

* Tolerate throws in wasm/* tests, add 2gb-in-4gb variants.

For browsers that don't support this large of wasm memory sizes,
consider as PASS, so that browser features don't block webgl
conformance.
For UAs that throw on use of large TypedArrays, FAIL but safely.

Also, Firefox *does* support ~4GB wasm memory sizes, but currently
throws when >2GB TypedArray views are passed to entrypoints. However,
Firefox does support <2GB-sized views of >2GB ArrayBuffers, so add tests
for that.
This reflects the ability for apps to use large WASM heaps, so long as
only smaller views are passed to webgl.
---
 sdk/tests/conformance2/wasm/00_test_list.txt  |  24 ++--
 .../wasm/bufferdata-16gb-wasm-memory.html     |  44 +++++---
 .../bufferdata-2gb-in-4gb-wasm-memory.html    |  64 +++++++++++
 .../wasm/bufferdata-4gb-wasm-memory.html      |  44 +++++---
 .../wasm/buffersubdata-16gb-wasm-memory.html  |  46 +++++---
 .../buffersubdata-2gb-in-4gb-wasm-memory.html |  65 +++++++++++
 .../wasm/buffersubdata-4gb-wasm-memory.html   |  46 +++++---
 .../getbuffersubdata-16gb-wasm-memory.html    |  39 ++++---
 ...tbuffersubdata-2gb-in-4gb-wasm-memory.html |  62 ++++++++++
 .../getbuffersubdata-4gb-wasm-memory.html     |  39 ++++---
 .../wasm/readpixels-16gb-wasm-memory.html     |  43 ++++---
 .../readpixels-2gb-in-4gb-wasm-memory.html    |  62 ++++++++++
 .../wasm/readpixels-4gb-wasm-memory.html      |  43 ++++---
 .../wasm/teximage2d-16gb-wasm-memory.html     | 104 +++++++++--------
 .../teximage2d-2gb-in-4gb-wasm-memory.html    | 101 +++++++++++++++++
 .../wasm/teximage2d-4gb-wasm-memory.html      | 105 +++++++++--------
 .../wasm/texsubimage2d-16gb-wasm-memory.html  | 106 ++++++++++--------
 .../texsubimage2d-2gb-in-4gb-wasm-memory.html | 101 +++++++++++++++++
 .../wasm/texsubimage2d-4gb-wasm-memory.html   | 106 ++++++++++--------
 19 files changed, 929 insertions(+), 315 deletions(-)
 create mode 100644 sdk/tests/conformance2/wasm/bufferdata-2gb-in-4gb-wasm-memory.html
 create mode 100644 sdk/tests/conformance2/wasm/buffersubdata-2gb-in-4gb-wasm-memory.html
 create mode 100644 sdk/tests/conformance2/wasm/getbuffersubdata-2gb-in-4gb-wasm-memory.html
 create mode 100644 sdk/tests/conformance2/wasm/readpixels-2gb-in-4gb-wasm-memory.html
 create mode 100644 sdk/tests/conformance2/wasm/teximage2d-2gb-in-4gb-wasm-memory.html
 create mode 100644 sdk/tests/conformance2/wasm/texsubimage2d-2gb-in-4gb-wasm-memory.html

diff --git a/sdk/tests/conformance2/wasm/00_test_list.txt b/sdk/tests/conformance2/wasm/00_test_list.txt
index d188fc30a..fe31a7e18 100644
--- a/sdk/tests/conformance2/wasm/00_test_list.txt
+++ b/sdk/tests/conformance2/wasm/00_test_list.txt
@@ -1,12 +1,18 @@
---min-version 2.0.1 readpixels-16gb-wasm-memory.html
---min-version 2.0.1 readpixels-4gb-wasm-memory.html
---min-version 2.0.1 teximage2d-16gb-wasm-memory.html
---min-version 2.0.1 teximage2d-4gb-wasm-memory.html
---min-version 2.0.1 texsubimage2d-16gb-wasm-memory.html
---min-version 2.0.1 texsubimage2d-4gb-wasm-memory.html
---min-version 2.0.1 bufferdata-16gb-wasm-memory.html
+--min-version 2.0.1 bufferdata-2gb-in-4gb-wasm-memory.html
 --min-version 2.0.1 bufferdata-4gb-wasm-memory.html
---min-version 2.0.1 buffersubdata-16gb-wasm-memory.html
+--min-version 2.0.1 bufferdata-16gb-wasm-memory.html
+--min-version 2.0.1 buffersubdata-2gb-in-4gb-wasm-memory.html
 --min-version 2.0.1 buffersubdata-4gb-wasm-memory.html
+--min-version 2.0.1 buffersubdata-16gb-wasm-memory.html
+--min-version 2.0.1 getbuffersubdata-2gb-in-4gb-wasm-memory.html
+--min-version 2.0.1 getbuffersubdata-4gb-wasm-memory.html
 --min-version 2.0.1 getbuffersubdata-16gb-wasm-memory.html
---min-version 2.0.1 getbuffersubdata-4gb-wasm-memory.html
\ No newline at end of file
+--min-version 2.0.1 readpixels-2gb-in-4gb-wasm-memory.html
+--min-version 2.0.1 readpixels-4gb-wasm-memory.html
+--min-version 2.0.1 readpixels-16gb-wasm-memory.html
+--min-version 2.0.1 teximage2d-2gb-in-4gb-wasm-memory.html
+--min-version 2.0.1 teximage2d-4gb-wasm-memory.html
+--min-version 2.0.1 teximage2d-16gb-wasm-memory.html
+--min-version 2.0.1 texsubimage2d-2gb-in-4gb-wasm-memory.html
+--min-version 2.0.1 texsubimage2d-4gb-wasm-memory.html
+--min-version 2.0.1 texsubimage2d-16gb-wasm-memory.html
diff --git a/sdk/tests/conformance2/wasm/bufferdata-16gb-wasm-memory.html b/sdk/tests/conformance2/wasm/bufferdata-16gb-wasm-memory.html
index 0dd21bf64..ca4d494e5 100644
--- a/sdk/tests/conformance2/wasm/bufferdata-16gb-wasm-memory.html
+++ b/sdk/tests/conformance2/wasm/bufferdata-16gb-wasm-memory.html
@@ -19,30 +19,42 @@
 <script>
 "use strict";
 description(document.title);
-debug("Tests that bufferData can be called on WebAssembly Memory of 16GB in size.");
+debug("Tests that bufferData can be called on the end of a WebAssembly Memory of 16GB in size.");
 debug("");
 let wtu = WebGLTestUtils;
 let gl = wtu.create3DContext("canvas", undefined, 2);
 
 const PAGE = 65536;
 const SIZE = 16 * 1024 * 1024 * 1024;
-let view = new Uint8Array(new WebAssembly.Memory({ index: 'i64', initial: SIZE / PAGE }).buffer);
-let expectedData = new Uint8Array([1, 2, 3, 4]);
-const length = expectedData.length;
-const offset = SIZE - length;
-view.set(expectedData, offset);
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ index: 'i64', initial: SIZE / PAGE }).buffer);
+  } catch (e) {
+    testPassed(`Allocating ${SIZE} threw: ${e}`);
+    return;
+  }
 
-let buf = gl.createBuffer();
-gl.bindBuffer(gl.ARRAY_BUFFER, buf);
-gl.bufferData(gl.ARRAY_BUFFER, view, gl.STATIC_DRAW, offset, length);
-wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  let expectedData = new Uint8Array([1, 2, 3, 4]);
+  const length = expectedData.length;
+  const offset = SIZE - length;
+  view.set(expectedData, offset);
 
-let actualData = new Uint8Array(length);
-gl.getBufferSubData(gl.ARRAY_BUFFER, 0, actualData);
-wtu.glErrorShouldBe(gl, gl.NO_ERROR);
-for (let i = 0; i < length; i++) {
-  shouldBe(`actualData[${i}]`, `expectedData[${i}]`);
-}
+  let buf = gl.createBuffer();
+  gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+  try {
+    gl.bufferData(gl.ARRAY_BUFFER, view, gl.STATIC_DRAW, offset, length);
+  } catch (e) {
+    testFailed(`bufferData from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+
+  let actualData = new Uint8Array(length);
+  gl.getBufferSubData(gl.ARRAY_BUFFER, 0, actualData);
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  expectArray(actualData, expectedData);
+})();
 
 var successfullyParsed = true;
 </script>
diff --git a/sdk/tests/conformance2/wasm/bufferdata-2gb-in-4gb-wasm-memory.html b/sdk/tests/conformance2/wasm/bufferdata-2gb-in-4gb-wasm-memory.html
new file mode 100644
index 000000000..cfe484e62
--- /dev/null
+++ b/sdk/tests/conformance2/wasm/bufferdata-2gb-in-4gb-wasm-memory.html
@@ -0,0 +1,64 @@
+<!--
+Copyright (c) 2024 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>bufferData test to Wasm Memory 4GB in size.</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 id="canvas" width="2" height="2" style="width: 40px; height: 40px;"></canvas>
+<div id="description"></div>
+<div id="console"></div>
+<script>
+"use strict";
+description(document.title);
+debug("Tests that bufferData can be called on the end of a ~2GB view into ~4GB of WebAssembly Memory.");
+debug("");
+let wtu = WebGLTestUtils;
+let gl = wtu.create3DContext("canvas", undefined, 2);
+
+const PAGE = 65536;
+const HEAP_SIZE = 4 * 1024 * 1024 * 1024 - PAGE;
+const VIEW_SIZE = 2 * 1024 * 1024 * 1024 - PAGE;
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ initial: HEAP_SIZE / PAGE }).buffer, 0, VIEW_SIZE);
+  } catch (e) {
+    testPassed(`Allocating ${HEAP_SIZE} threw: ${e}`);
+    return;
+  }
+
+  let expectedData = new Uint8Array([1, 2, 3, 4]);
+  const length = expectedData.length;
+  const offset = view.length - length;
+  view.set(expectedData, offset);
+
+  let buf = gl.createBuffer();
+  gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+  try {
+    gl.bufferData(gl.ARRAY_BUFFER, view, gl.STATIC_DRAW, offset, length);
+  } catch (e) {
+    testFailed(`bufferData from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+
+  let actualData = new Uint8Array(length);
+  gl.getBufferSubData(gl.ARRAY_BUFFER, 0, actualData);
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  expectArray(actualData, expectedData);
+})();
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/sdk/tests/conformance2/wasm/bufferdata-4gb-wasm-memory.html b/sdk/tests/conformance2/wasm/bufferdata-4gb-wasm-memory.html
index 2296c3a5e..62d468b02 100644
--- a/sdk/tests/conformance2/wasm/bufferdata-4gb-wasm-memory.html
+++ b/sdk/tests/conformance2/wasm/bufferdata-4gb-wasm-memory.html
@@ -19,30 +19,42 @@
 <script>
 "use strict";
 description(document.title);
-debug("Tests that bufferData can be called on WebAssembly Memory of 4GB in size.");
+debug("Tests that bufferData can be called on the end of a WebAssembly Memory of nearly 4GB in size.");
 debug("");
 let wtu = WebGLTestUtils;
 let gl = wtu.create3DContext("canvas", undefined, 2);
 
 const PAGE = 65536;
 const SIZE = 4 * 1024 * 1024 * 1024 - PAGE;
-let view = new Uint8Array(new WebAssembly.Memory({ initial: SIZE / PAGE }).buffer);
-let expectedData = new Uint8Array([1, 2, 3, 4]);
-const length = expectedData.length;
-const offset = SIZE - length;
-view.set(expectedData, offset);
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ initial: SIZE / PAGE }).buffer);
+  } catch (e) {
+    testPassed(`Allocating ${SIZE} threw: ${e}`);
+    return;
+  }
 
-let buf = gl.createBuffer();
-gl.bindBuffer(gl.ARRAY_BUFFER, buf);
-gl.bufferData(gl.ARRAY_BUFFER, view, gl.STATIC_DRAW, offset, length);
-wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  let expectedData = new Uint8Array([1, 2, 3, 4]);
+  const length = expectedData.length;
+  const offset = SIZE - length;
+  view.set(expectedData, offset);
 
-let actualData = new Uint8Array(length);
-gl.getBufferSubData(gl.ARRAY_BUFFER, 0, actualData);
-wtu.glErrorShouldBe(gl, gl.NO_ERROR);
-for (let i = 0; i < length; i++) {
-  shouldBe(`actualData[${i}]`, `expectedData[${i}]`);
-}
+  let buf = gl.createBuffer();
+  gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+  try {
+    gl.bufferData(gl.ARRAY_BUFFER, view, gl.STATIC_DRAW, offset, length);
+  } catch (e) {
+    testFailed(`bufferData from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+
+  let actualData = new Uint8Array(length);
+  gl.getBufferSubData(gl.ARRAY_BUFFER, 0, actualData);
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  expectArray(actualData, expectedData);
+})();
 
 var successfullyParsed = true;
 </script>
diff --git a/sdk/tests/conformance2/wasm/buffersubdata-16gb-wasm-memory.html b/sdk/tests/conformance2/wasm/buffersubdata-16gb-wasm-memory.html
index 08d6d1df5..7ce95d8e3 100644
--- a/sdk/tests/conformance2/wasm/buffersubdata-16gb-wasm-memory.html
+++ b/sdk/tests/conformance2/wasm/buffersubdata-16gb-wasm-memory.html
@@ -19,31 +19,43 @@
 <script>
 "use strict";
 description(document.title);
-debug("Tests that bufferSubData can be called on WebAssembly Memory of 16GB in size.");
+debug("Tests that bufferSubData can be called on the end of a WebAssembly Memory of 16GB in size.");
 debug("");
 let wtu = WebGLTestUtils;
 let gl = wtu.create3DContext("canvas", undefined, 2);
 
 const PAGE = 65536;
 const SIZE = 16 * 1024 * 1024 * 1024;
-let view = new Uint8Array(new WebAssembly.Memory({ index: 'i64', initial: SIZE / PAGE }).buffer);
-let expectedData = new Uint8Array([1, 2]);
-const length = expectedData.length;
-let srcOffset = SIZE - length;
-view.set(expectedData, srcOffset);
-const dstByteOffset = 4;
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ index: 'i64', initial: SIZE / PAGE }).buffer);
+  } catch (e) {
+    testPassed(`Allocating ${SIZE} threw: ${e}`);
+    return;
+  }
 
-let buf = gl.createBuffer();
-gl.bindBuffer(gl.ARRAY_BUFFER, buf);
-gl.bufferData(gl.ARRAY_BUFFER, 8, gl.STATIC_DRAW);
-gl.bufferSubData(gl.ARRAY_BUFFER, dstByteOffset, view, srcOffset, length);
-wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  let expectedData = new Uint8Array([1, 2]);
+  const length = expectedData.length;
+  let srcOffset = SIZE - length;
+  view.set(expectedData, srcOffset);
+  const dstByteOffset = 4;
 
-let actualData = new Uint8Array(length);
-gl.getBufferSubData(gl.ARRAY_BUFFER, dstByteOffset, actualData);
-for (let i = 0; i < length; i++) {
-  shouldBe(`actualData[${i}]`, `expectedData[${i}]`);
-}
+  let buf = gl.createBuffer();
+  gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+  gl.bufferData(gl.ARRAY_BUFFER, 8, gl.STATIC_DRAW);
+  try {
+    gl.bufferSubData(gl.ARRAY_BUFFER, dstByteOffset, view, srcOffset, length);
+  } catch (e) {
+    testFailed(`bufferSubData from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+
+  let actualData = new Uint8Array(length);
+  gl.getBufferSubData(gl.ARRAY_BUFFER, dstByteOffset, actualData);
+  expectArray(actualData, expectedData);
+})();
 
 var successfullyParsed = true;
 </script>
diff --git a/sdk/tests/conformance2/wasm/buffersubdata-2gb-in-4gb-wasm-memory.html b/sdk/tests/conformance2/wasm/buffersubdata-2gb-in-4gb-wasm-memory.html
new file mode 100644
index 000000000..ab6fd84ff
--- /dev/null
+++ b/sdk/tests/conformance2/wasm/buffersubdata-2gb-in-4gb-wasm-memory.html
@@ -0,0 +1,65 @@
+<!--
+Copyright (c) 2024 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>bufferSubData test to Wasm Memory 4GB in size.</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 id="canvas" width="2" height="2" style="width: 40px; height: 40px;"></canvas>
+<div id="description"></div>
+<div id="console"></div>
+<script>
+"use strict";
+description(document.title);
+debug("Tests that bufferSubData can be called on the end of a ~2GB view into ~4GB of WebAssembly Memory.");
+debug("");
+let wtu = WebGLTestUtils;
+let gl = wtu.create3DContext("canvas", undefined, 2);
+
+const PAGE = 65536;
+const HEAP_SIZE = 4 * 1024 * 1024 * 1024 - PAGE;
+const VIEW_SIZE = 2 * 1024 * 1024 * 1024 - PAGE;
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ initial: HEAP_SIZE / PAGE }).buffer, 0, VIEW_SIZE);
+  } catch (e) {
+    testPassed(`Allocating ${HEAP_SIZE} threw: ${e}`);
+    return;
+  }
+
+  let expectedData = new Uint8Array([1, 2]);
+  const length = expectedData.length;
+  let srcOffset = view.length - length;
+  view.set(expectedData, srcOffset);
+  const dstByteOffset = 4;
+
+  let buf = gl.createBuffer();
+  gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+  gl.bufferData(gl.ARRAY_BUFFER, 8, gl.STATIC_DRAW);
+  try {
+    gl.bufferSubData(gl.ARRAY_BUFFER, dstByteOffset, view, srcOffset, length);
+  } catch (e) {
+    testFailed(`bufferSubData from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+
+  let actualData = new Uint8Array(length);
+  gl.getBufferSubData(gl.ARRAY_BUFFER, dstByteOffset, actualData);
+  expectArray(actualData, expectedData);
+})();
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/sdk/tests/conformance2/wasm/buffersubdata-4gb-wasm-memory.html b/sdk/tests/conformance2/wasm/buffersubdata-4gb-wasm-memory.html
index 2834a6901..c25200e1e 100644
--- a/sdk/tests/conformance2/wasm/buffersubdata-4gb-wasm-memory.html
+++ b/sdk/tests/conformance2/wasm/buffersubdata-4gb-wasm-memory.html
@@ -19,31 +19,43 @@
 <script>
 "use strict";
 description(document.title);
-debug("Tests that bufferSubData can be called on WebAssembly Memory of 4GB in size.");
+debug("Tests that bufferSubData can be called on the end of a WebAssembly Memory of nearly 4GB in size.");
 debug("");
 let wtu = WebGLTestUtils;
 let gl = wtu.create3DContext("canvas", undefined, 2);
 
 const PAGE = 65536;
 const SIZE = 4 * 1024 * 1024 * 1024 - PAGE;
-let view = new Uint8Array(new WebAssembly.Memory({ initial: SIZE / PAGE }).buffer);
-let expectedData = new Uint8Array([1, 2]);
-const length = expectedData.length;
-let srcOffset = SIZE - length;
-view.set(expectedData, srcOffset);
-const dstByteOffset = 4;
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ initial: SIZE / PAGE }).buffer);
+  } catch (e) {
+    testPassed(`Allocating ${SIZE} threw: ${e}`);
+    return;
+  }
 
-let buf = gl.createBuffer();
-gl.bindBuffer(gl.ARRAY_BUFFER, buf);
-gl.bufferData(gl.ARRAY_BUFFER, 8, gl.STATIC_DRAW);
-gl.bufferSubData(gl.ARRAY_BUFFER, dstByteOffset, view, srcOffset, length);
-wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  let expectedData = new Uint8Array([1, 2]);
+  const length = expectedData.length;
+  let srcOffset = SIZE - length;
+  view.set(expectedData, srcOffset);
+  const dstByteOffset = 4;
 
-let actualData = new Uint8Array(length);
-gl.getBufferSubData(gl.ARRAY_BUFFER, dstByteOffset, actualData);
-for (let i = 0; i < length; i++) {
-  shouldBe(`actualData[${i}]`, `expectedData[${i}]`);
-}
+  let buf = gl.createBuffer();
+  gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+  gl.bufferData(gl.ARRAY_BUFFER, 8, gl.STATIC_DRAW);
+  try {
+    gl.bufferSubData(gl.ARRAY_BUFFER, dstByteOffset, view, srcOffset, length);
+  } catch (e) {
+    testFailed(`bufferSubData from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+
+  let actualData = new Uint8Array(length);
+  gl.getBufferSubData(gl.ARRAY_BUFFER, dstByteOffset, actualData);
+  expectArray(actualData, expectedData);
+})();
 
 var successfullyParsed = true;
 </script>
diff --git a/sdk/tests/conformance2/wasm/getbuffersubdata-16gb-wasm-memory.html b/sdk/tests/conformance2/wasm/getbuffersubdata-16gb-wasm-memory.html
index 8390957b0..724a9bfa1 100644
--- a/sdk/tests/conformance2/wasm/getbuffersubdata-16gb-wasm-memory.html
+++ b/sdk/tests/conformance2/wasm/getbuffersubdata-16gb-wasm-memory.html
@@ -19,27 +19,40 @@
 <script>
 "use strict";
 description(document.title);
-debug("Tests that getBufferSubData can be called on WebAssembly Memory of 16GB in size.");
+debug("Tests that getBufferSubData can be called on the end of a WebAssembly Memory of 16GB in size.");
 debug("");
 let wtu = WebGLTestUtils;
 let gl = wtu.create3DContext("canvas", undefined, 2);
 
 const PAGE = 65536;
 const SIZE = 16 * 1024 * 1024 * 1024;
-let view = new Uint8Array(new WebAssembly.Memory({ index: 'i64', initial: SIZE / PAGE }).buffer);
-let expectedData = new Uint8Array([1, 2, 3, 4]);
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ index: 'i64', initial: SIZE / PAGE }).buffer);
+  } catch (e) {
+    testPassed(`Allocating ${SIZE} threw: ${e}`);
+    return;
+  }
 
-let buf = gl.createBuffer();
-gl.bindBuffer(gl.ARRAY_BUFFER, buf);
-gl.bufferData(gl.ARRAY_BUFFER, expectedData, gl.STATIC_DRAW);
+  let expectedData = new Uint8Array([1, 2, 3, 4]);
 
-const length = expectedData.length;
-const offset = SIZE - length;
-gl.getBufferSubData(gl.ARRAY_BUFFER, 0, view, offset, length);
-wtu.glErrorShouldBe(gl, gl.NO_ERROR);
-for (let i = 0; i < length; i++) {
-  shouldBe(`view[${i + offset}]`, `expectedData[${i}]`);
-}
+  let buf = gl.createBuffer();
+  gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+  gl.bufferData(gl.ARRAY_BUFFER, expectedData, gl.STATIC_DRAW);
+
+  const length = expectedData.length;
+  const offset = SIZE - length;
+  try {
+    gl.getBufferSubData(gl.ARRAY_BUFFER, 0, view, offset, length);
+  } catch (e) {
+    testFailed(`getBufferSubData from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  let actualData = view.subarray(offset, offset+4);
+  expectArray(actualData, expectedData);
+})();
 
 var successfullyParsed = true;
 </script>
diff --git a/sdk/tests/conformance2/wasm/getbuffersubdata-2gb-in-4gb-wasm-memory.html b/sdk/tests/conformance2/wasm/getbuffersubdata-2gb-in-4gb-wasm-memory.html
new file mode 100644
index 000000000..91ad7653d
--- /dev/null
+++ b/sdk/tests/conformance2/wasm/getbuffersubdata-2gb-in-4gb-wasm-memory.html
@@ -0,0 +1,62 @@
+<!--
+Copyright (c) 2024 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>getBufferSubData test to Wasm Memory 4GB in size.</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 id="canvas" width="2" height="2" style="width: 40px; height: 40px;"></canvas>
+<div id="description"></div>
+<div id="console"></div>
+<script>
+"use strict";
+description(document.title);
+debug("Tests that getBufferSubData can be called on the end of a ~2GB view into ~4GB of WebAssembly Memory.");
+debug("");
+let wtu = WebGLTestUtils;
+let gl = wtu.create3DContext("canvas", undefined, 2);
+
+const PAGE = 65536;
+const HEAP_SIZE = 4 * 1024 * 1024 * 1024 - PAGE;
+const VIEW_SIZE = 2 * 1024 * 1024 * 1024 - PAGE;
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ initial: HEAP_SIZE / PAGE }).buffer, 0, VIEW_SIZE);
+  } catch (e) {
+    testPassed(`Allocating ${HEAP_SIZE} threw: ${e}`);
+    return;
+  }
+
+  let expectedData = new Uint8Array([1, 2, 3, 4]);
+
+  let buf = gl.createBuffer();
+  gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+  gl.bufferData(gl.ARRAY_BUFFER, expectedData, gl.STATIC_DRAW);
+
+  const length = expectedData.length;
+  const offset = view.length - length;
+  try {
+    gl.getBufferSubData(gl.ARRAY_BUFFER, 0, view, offset, length);
+  } catch (e) {
+    testFailed(`getBufferSubData from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  let actualData = view.subarray(offset, offset+4);
+  expectArray(actualData, expectedData);
+})();
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/sdk/tests/conformance2/wasm/getbuffersubdata-4gb-wasm-memory.html b/sdk/tests/conformance2/wasm/getbuffersubdata-4gb-wasm-memory.html
index 09a336b75..90c9b6610 100644
--- a/sdk/tests/conformance2/wasm/getbuffersubdata-4gb-wasm-memory.html
+++ b/sdk/tests/conformance2/wasm/getbuffersubdata-4gb-wasm-memory.html
@@ -19,27 +19,40 @@
 <script>
 "use strict";
 description(document.title);
-debug("Tests that getBufferSubData can be called on WebAssembly Memory of 4GB in size.");
+debug("Tests that getBufferSubData can be called on the end of a WebAssembly Memory of nearly 4GB in size.");
 debug("");
 let wtu = WebGLTestUtils;
 let gl = wtu.create3DContext("canvas", undefined, 2);
 
 const PAGE = 65536;
 const SIZE = 4 * 1024 * 1024 * 1024 - PAGE;
-let view = new Uint8Array(new WebAssembly.Memory({ initial: SIZE / PAGE }).buffer);
-let expectedData = new Uint8Array([1, 2, 3, 4]);
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ initial: SIZE / PAGE }).buffer);
+  } catch (e) {
+    testPassed(`Allocating ${SIZE} threw: ${e}`);
+    return;
+  }
 
-let buf = gl.createBuffer();
-gl.bindBuffer(gl.ARRAY_BUFFER, buf);
-gl.bufferData(gl.ARRAY_BUFFER, expectedData, gl.STATIC_DRAW);
+  let expectedData = new Uint8Array([1, 2, 3, 4]);
 
-const length = expectedData.length;
-const offset = SIZE - length;
-gl.getBufferSubData(gl.ARRAY_BUFFER, 0, view, offset, length);
-wtu.glErrorShouldBe(gl, gl.NO_ERROR);
-for (let i = 0; i < length; i++) {
-  shouldBe(`view[${i + offset}]`, `expectedData[${i}]`);
-}
+  let buf = gl.createBuffer();
+  gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+  gl.bufferData(gl.ARRAY_BUFFER, expectedData, gl.STATIC_DRAW);
+
+  const length = expectedData.length;
+  const offset = SIZE - length;
+  try {
+    gl.getBufferSubData(gl.ARRAY_BUFFER, 0, view, offset, length);
+  } catch (e) {
+    testFailed(`getBufferSubData from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  let actualData = view.subarray(offset, offset+4);
+  expectArray(actualData, expectedData);
+})();
 
 var successfullyParsed = true;
 </script>
diff --git a/sdk/tests/conformance2/wasm/readpixels-16gb-wasm-memory.html b/sdk/tests/conformance2/wasm/readpixels-16gb-wasm-memory.html
index af74678dd..21c65a2c7 100644
--- a/sdk/tests/conformance2/wasm/readpixels-16gb-wasm-memory.html
+++ b/sdk/tests/conformance2/wasm/readpixels-16gb-wasm-memory.html
@@ -20,30 +20,41 @@
 "use strict";
 description(document.title);
 debug("");
-debug("Tests that gl.readPixels() can be called on WebAssembly Memory of 16GB in size.");
+debug("Tests that readPixels can be called on the end of a WebAssembly Memory of 16GB in size.");
 debug("");
 let wtu = WebGLTestUtils;
 let gl = wtu.create3DContext("canvas", undefined, 2);
 
 const PAGE = 65536;
 const SIZE = 16*1024*1024*1024;
-let view = new Uint8Array(new WebAssembly.Memory({ index: 'i64', initial: SIZE/PAGE }).buffer);
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ index: 'i64', initial: SIZE / PAGE }).buffer);
+  } catch (e) {
+    testPassed(`Allocating ${SIZE} threw: ${e}`);
+    return;
+  }
 
-// Clear the canvas to a specific color
-const expectedColor = [42, 84, 128, 255];
-gl.clearColor(expectedColor[0]/255.0, expectedColor[1]/255.0, expectedColor[2]/255.0, expectedColor[3]/255.0);
-gl.clear(gl.COLOR_BUFFER_BIT);
+  // Clear the canvas to a specific color
+  const expectedColor = [42, 84, 128, 255];
+  gl.clearColor(expectedColor[0]/255.0, expectedColor[1]/255.0, expectedColor[2]/255.0, expectedColor[3]/255.0);
+  gl.clear(gl.COLOR_BUFFER_BIT);
+
+  // Test that gl.readPixels() can be called with a high offset to Memory
+  const offset = SIZE - 4;
+  view.set([0,0,0,0], offset); // For good measure, clear data at offset before reading
+  try {
+    gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, view, offset);
+  } catch (e) {
+    testFailed(`readPixels from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  let obtainedColor = view.subarray(offset, offset+4);
+  expectArray(obtainedColor, expectedColor);
+})();
 
-// Test that gl.readPixels() can be called with a high offset to Memory
-const offset = SIZE - 4;
-view.set([0,0,0,0], offset); // For good measure, clear data at offset before reading
-gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, view, offset);
-wtu.glErrorShouldBe(gl, gl.NO_ERROR);
-let obtainedColor = view.subarray(offset, offset+4);
-shouldBe('obtainedColor[0]', 'expectedColor[0]');
-shouldBe('obtainedColor[1]', 'expectedColor[1]');
-shouldBe('obtainedColor[2]', 'expectedColor[2]');
-shouldBe('obtainedColor[3]', 'expectedColor[3]');
 var successfullyParsed = true;
 </script>
 <script src="../../js/js-test-post.js"></script>
diff --git a/sdk/tests/conformance2/wasm/readpixels-2gb-in-4gb-wasm-memory.html b/sdk/tests/conformance2/wasm/readpixels-2gb-in-4gb-wasm-memory.html
new file mode 100644
index 000000000..175d07cef
--- /dev/null
+++ b/sdk/tests/conformance2/wasm/readpixels-2gb-in-4gb-wasm-memory.html
@@ -0,0 +1,62 @@
+<!--
+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>gl.readPixels() test to Wasm Memory 4GB in size.</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 id="canvas" width="2" height="2" style="width: 40px; height: 40px;"></canvas>
+<div id="description"></div>
+<div id="console"></div>
+<script>
+"use strict";
+description(document.title);
+debug("Tests that readPixels can be called on the end of a ~2GB view into ~4GB of WebAssembly Memory.");
+debug("");
+let wtu = WebGLTestUtils;
+let gl = wtu.create3DContext("canvas", undefined, 2);
+
+const PAGE = 65536;
+const HEAP_SIZE = 4 * 1024 * 1024 * 1024 - PAGE;
+const VIEW_SIZE = 2 * 1024 * 1024 * 1024 - PAGE;
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ initial: HEAP_SIZE / PAGE }).buffer, 0, VIEW_SIZE);
+  } catch (e) {
+    testPassed(`Allocating ${HEAP_SIZE} threw: ${e}`);
+    return;
+  }
+
+  // Clear the canvas to a specific color
+  const expectedColor = [42, 84, 128, 255];
+  gl.clearColor(expectedColor[0]/255.0, expectedColor[1]/255.0, expectedColor[2]/255.0, expectedColor[3]/255.0);
+  gl.clear(gl.COLOR_BUFFER_BIT);
+
+  // Test that gl.readPixels() can be called with a high offset to Memory
+  const offset = view.length - expectedColor.length;
+  view.set([0,0,0,0], offset); // For good measure, clear data at offset before reading
+  try {
+    gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, view, offset);
+  } catch (e) {
+    testFailed(`readPixels from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  let obtainedColor = view.subarray(offset, offset+4);
+  expectArray(obtainedColor, expectedColor);
+})();
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/sdk/tests/conformance2/wasm/readpixels-4gb-wasm-memory.html b/sdk/tests/conformance2/wasm/readpixels-4gb-wasm-memory.html
index f97a3ccba..c9fe15476 100644
--- a/sdk/tests/conformance2/wasm/readpixels-4gb-wasm-memory.html
+++ b/sdk/tests/conformance2/wasm/readpixels-4gb-wasm-memory.html
@@ -19,30 +19,41 @@
 <script>
 "use strict";
 description(document.title);
-debug("Tests that gl.readPixels() can be called on WebAssembly Memory of 4GB in size.");
+debug("Tests that readPixels can be called on the end of a WebAssembly Memory of nearly 4GB in size.");
 debug("");
 let wtu = WebGLTestUtils;
 let gl = wtu.create3DContext("canvas", undefined, 2);
 
 const PAGE = 65536;
 const SIZE = 4*1024*1024*1024 - PAGE; // when uint32_t size is max, we can only reach one page short of full 4GB
-let view = new Uint8Array(new WebAssembly.Memory({ initial: SIZE/PAGE }).buffer);
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ initial: SIZE / PAGE }).buffer);
+  } catch (e) {
+    testPassed(`Allocating ${SIZE} threw: ${e}`);
+    return;
+  }
 
-// Clear the canvas to a specific color
-const expectedColor = [42, 84, 128, 255];
-gl.clearColor(expectedColor[0]/255.0, expectedColor[1]/255.0, expectedColor[2]/255.0, expectedColor[3]/255.0);
-gl.clear(gl.COLOR_BUFFER_BIT);
+  // Clear the canvas to a specific color
+  const expectedColor = [42, 84, 128, 255];
+  gl.clearColor(expectedColor[0]/255.0, expectedColor[1]/255.0, expectedColor[2]/255.0, expectedColor[3]/255.0);
+  gl.clear(gl.COLOR_BUFFER_BIT);
+
+  // Test that gl.readPixels() can be called with a high offset to Memory
+  const offset = SIZE - 4;
+  view.set([0,0,0,0], offset); // For good measure, clear data at offset before reading
+  try {
+    gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, view, offset);
+  } catch (e) {
+    testFailed(`readPixels from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  let obtainedColor = view.subarray(offset, offset+4);
+  expectArray(obtainedColor, expectedColor);
+})();
 
-// Test that gl.readPixels() can be called with a high offset to Memory
-const offset = SIZE - 4;
-view.set([0,0,0,0], offset); // For good measure, clear data at offset before reading
-gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, view, offset);
-wtu.glErrorShouldBe(gl, gl.NO_ERROR);
-let obtainedColor = view.subarray(offset, offset+4);
-shouldBe('obtainedColor[0]', 'expectedColor[0]');
-shouldBe('obtainedColor[1]', 'expectedColor[1]');
-shouldBe('obtainedColor[2]', 'expectedColor[2]');
-shouldBe('obtainedColor[3]', 'expectedColor[3]');
 var successfullyParsed = true;
 </script>
 <script src="../../js/js-test-post.js"></script>
diff --git a/sdk/tests/conformance2/wasm/teximage2d-16gb-wasm-memory.html b/sdk/tests/conformance2/wasm/teximage2d-16gb-wasm-memory.html
index 8ce511195..0f39e2ceb 100644
--- a/sdk/tests/conformance2/wasm/teximage2d-16gb-wasm-memory.html
+++ b/sdk/tests/conformance2/wasm/teximage2d-16gb-wasm-memory.html
@@ -19,65 +19,79 @@
 <script>
 "use strict";
 description(document.title);
-debug("Tests that gl.texImage2D() can be called on WebAssembly Memory 16GB in size.");
+debug("Tests that texImage2D can be called on the end of a WebAssembly Memory of 16GB in size.");
 debug("");
 let wtu = WebGLTestUtils;
 let gl = wtu.create3DContext("canvas", undefined, 2);
 
 const PAGE = 65536;
 const SIZE = 16*1024*1024*1024;
-let view = new Uint8Array(new WebAssembly.Memory({ index: 'i64', initial: SIZE/PAGE }).buffer);
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ index: 'i64', initial: SIZE / PAGE }).buffer);
+  } catch (e) {
+    testPassed(`Allocating ${SIZE} threw: ${e}`);
+    return;
+  }
 
-function compileShader(type, src) {
-  let shader = gl.createShader(type);
-  gl.shaderSource(shader, src);
-  gl.compileShader(shader);
-  let log = gl.getShaderInfoLog(shader);
-  if (log) debug(log);
-  return shader;
-}
+  function compileShader(type, src) {
+    let shader = gl.createShader(type);
+    gl.shaderSource(shader, src);
+    gl.compileShader(shader);
+    let log = gl.getShaderInfoLog(shader);
+    if (log) debug(log);
+    return shader;
+  }
 
-function createProgram(vs, fs) {
-  let program = gl.createProgram();
-  gl.attachShader(program, vs);
-  gl.attachShader(program, fs);
-  gl.bindAttribLocation(program, 0, 'pos');
-  gl.linkProgram(program);
-  gl.useProgram(program);
-  return program;
-}
+  function createProgram(vs, fs) {
+    let program = gl.createProgram();
+    gl.attachShader(program, vs);
+    gl.attachShader(program, fs);
+    gl.bindAttribLocation(program, 0, 'pos');
+    gl.linkProgram(program);
+    gl.useProgram(program);
+    return program;
+  }
 
-let program = createProgram(
-  compileShader(gl.VERTEX_SHADER, `
-    varying vec2 uv;
-    attribute vec2 pos;
-    void main() { uv = pos; gl_Position = vec4(pos*2.0-vec2(1.0,1.0),0,1); }`),
-  compileShader(gl.FRAGMENT_SHADER, `
-    precision lowp float;
-    uniform sampler2D tex;
-    varying vec2 uv;
-    void main() { gl_FragColor = texture2D(tex,uv); }`));
+  let program = createProgram(
+    compileShader(gl.VERTEX_SHADER, `
+      varying vec2 uv;
+      attribute vec2 pos;
+      void main() { uv = pos; gl_Position = vec4(pos*2.0-vec2(1.0,1.0),0,1); }`),
+    compileShader(gl.FRAGMENT_SHADER, `
+      precision lowp float;
+      uniform sampler2D tex;
+      varying vec2 uv;
+      void main() { gl_FragColor = texture2D(tex,uv); }`));
 
-gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
-gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]), gl.STATIC_DRAW);
-gl.vertexAttribPointer(0, 2, gl.FLOAT, gl.FALSE, 0, 0);
-gl.enableVertexAttribArray(0);
+  gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
+  gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]), gl.STATIC_DRAW);
+  gl.vertexAttribPointer(0, 2, gl.FLOAT, gl.FALSE, 0, 0);
+  gl.enableVertexAttribArray(0);
 
-let texture = gl.createTexture();
-gl.bindTexture(gl.TEXTURE_2D, texture);
+  let texture = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, texture);
 
-// Test uploading an image
-const expectedColor = [42, 84, 128, 255];
-const offset = SIZE - 4;
-view.set(expectedColor, offset);
-gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, view, offset);
-wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  // Test uploading an image
+  const expectedColor = [42, 84, 128, 255];
+  const offset = SIZE - 4;
+  view.set(expectedColor, offset);
+  try {
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, view, offset);
+  } catch (e) {
+    testFailed(`texImage2D from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
 
-// Test rendering with that image
-gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+  // Test rendering with that image
+  gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+
+  // Verify that we rendered what we expected
+  wtu.checkCanvasRect(gl, 0, 0, 1, 1, expectedColor, "texImage2D produced expected color");
+})();
 
-// Verify that we rendered what we expected
-wtu.checkCanvasRect(gl, 0, 0, 1, 1, expectedColor, "texImage2D produced expected color");
 var successfullyParsed = true;
 </script>
 <script src="../../js/js-test-post.js"></script>
diff --git a/sdk/tests/conformance2/wasm/teximage2d-2gb-in-4gb-wasm-memory.html b/sdk/tests/conformance2/wasm/teximage2d-2gb-in-4gb-wasm-memory.html
new file mode 100644
index 000000000..dc1d1277a
--- /dev/null
+++ b/sdk/tests/conformance2/wasm/teximage2d-2gb-in-4gb-wasm-memory.html
@@ -0,0 +1,101 @@
+<!--
+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>gl.texImage2D() test to Wasm Memory 4GB in size.</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 id="canvas" width="2" height="2" style="width: 40px; height: 40px;"></canvas>
+<div id="description"></div>
+<div id="console"></div>
+<script>
+"use strict";
+description(document.title);
+debug("Tests that texImage2D can be called on the end of a ~2GB view into ~4GB of WebAssembly Memory.");
+debug("");
+let wtu = WebGLTestUtils;
+let gl = wtu.create3DContext("canvas", undefined, 2);
+
+const PAGE = 65536;
+const HEAP_SIZE = 4 * 1024 * 1024 * 1024 - PAGE;
+const VIEW_SIZE = 2 * 1024 * 1024 * 1024 - PAGE;
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ initial: HEAP_SIZE / PAGE }).buffer, 0, VIEW_SIZE);
+  } catch (e) {
+    testPassed(`Allocating ${HEAP_SIZE} threw: ${e}`);
+    return;
+  }
+
+
+  function compileShader(type, src) {
+    let shader = gl.createShader(type);
+    gl.shaderSource(shader, src);
+    gl.compileShader(shader);
+    let log = gl.getShaderInfoLog(shader);
+    if (log) debug(log);
+    return shader;
+  }
+
+  function createProgram(vs, fs) {
+    let program = gl.createProgram();
+    gl.attachShader(program, vs);
+    gl.attachShader(program, fs);
+    gl.bindAttribLocation(program, 0, 'pos');
+    gl.linkProgram(program);
+    gl.useProgram(program);
+    return program;
+  }
+
+  let program = createProgram(
+    compileShader(gl.VERTEX_SHADER, `
+      varying vec2 uv;
+      attribute vec2 pos;
+      void main() { uv = pos; gl_Position = vec4(pos*2.0-vec2(1.0,1.0),0,1); }`),
+    compileShader(gl.FRAGMENT_SHADER, `
+      precision lowp float;
+      uniform sampler2D tex;
+      varying vec2 uv;
+      void main() { gl_FragColor = texture2D(tex,uv); }`));
+
+  gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
+  gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]), gl.STATIC_DRAW);
+  gl.vertexAttribPointer(0, 2, gl.FLOAT, gl.FALSE, 0, 0);
+  gl.enableVertexAttribArray(0);
+
+  let texture = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, texture);
+
+  // Test uploading an image
+  const expectedColor = [42, 84, 128, 255];
+  const offset = view.length - expectedColor.length;
+  view.set(expectedColor, offset);
+  try {
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, view, offset);
+  } catch (e) {
+    testFailed(`texImage2D from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+
+  // Test rendering with that image
+  gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+
+  // Verify that we rendered what we expected
+  wtu.checkCanvasRect(gl, 0, 0, 1, 1, expectedColor, "texImage2D produced expected color");
+})();
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/sdk/tests/conformance2/wasm/teximage2d-4gb-wasm-memory.html b/sdk/tests/conformance2/wasm/teximage2d-4gb-wasm-memory.html
index 5d6897347..ccd2a4a8f 100644
--- a/sdk/tests/conformance2/wasm/teximage2d-4gb-wasm-memory.html
+++ b/sdk/tests/conformance2/wasm/teximage2d-4gb-wasm-memory.html
@@ -19,65 +19,80 @@
 <script>
 "use strict";
 description(document.title);
-debug("Tests that gl.texImage2D() can be called on WebAssembly Memory 4GB in size.");
+debug("Tests that texImage2D can be called on the end of a WebAssembly Memory of nearly 4GB in size.");
 debug("");
 let wtu = WebGLTestUtils;
 let gl = wtu.create3DContext("canvas", undefined, 2);
 
 const PAGE = 65536;
 const SIZE = 4*1024*1024*1024 - PAGE; // when uint32_t size is max, we can only reach one page short of full 4GB
-let view = new Uint8Array(new WebAssembly.Memory({ initial: SIZE/PAGE }).buffer);
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ initial: SIZE / PAGE }).buffer);
+  } catch (e) {
+    testPassed(`Allocating ${SIZE} threw: ${e}`);
+    return;
+  }
 
-function compileShader(type, src) {
-  let shader = gl.createShader(type);
-  gl.shaderSource(shader, src);
-  gl.compileShader(shader);
-  let log = gl.getShaderInfoLog(shader);
-  if (log) debug(log);
-  return shader;
-}
 
-function createProgram(vs, fs) {
-  let program = gl.createProgram();
-  gl.attachShader(program, vs);
-  gl.attachShader(program, fs);
-  gl.bindAttribLocation(program, 0, 'pos');
-  gl.linkProgram(program);
-  gl.useProgram(program);
-  return program;
-}
+  function compileShader(type, src) {
+    let shader = gl.createShader(type);
+    gl.shaderSource(shader, src);
+    gl.compileShader(shader);
+    let log = gl.getShaderInfoLog(shader);
+    if (log) debug(log);
+    return shader;
+  }
 
-let program = createProgram(
-  compileShader(gl.VERTEX_SHADER, `
-    varying vec2 uv;
-    attribute vec2 pos;
-    void main() { uv = pos; gl_Position = vec4(pos*2.0-vec2(1.0,1.0),0,1); }`),
-  compileShader(gl.FRAGMENT_SHADER, `
-    precision lowp float;
-    uniform sampler2D tex;
-    varying vec2 uv;
-    void main() { gl_FragColor = texture2D(tex,uv); }`));
+  function createProgram(vs, fs) {
+    let program = gl.createProgram();
+    gl.attachShader(program, vs);
+    gl.attachShader(program, fs);
+    gl.bindAttribLocation(program, 0, 'pos');
+    gl.linkProgram(program);
+    gl.useProgram(program);
+    return program;
+  }
 
-gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
-gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]), gl.STATIC_DRAW);
-gl.vertexAttribPointer(0, 2, gl.FLOAT, gl.FALSE, 0, 0);
-gl.enableVertexAttribArray(0);
+  let program = createProgram(
+    compileShader(gl.VERTEX_SHADER, `
+      varying vec2 uv;
+      attribute vec2 pos;
+      void main() { uv = pos; gl_Position = vec4(pos*2.0-vec2(1.0,1.0),0,1); }`),
+    compileShader(gl.FRAGMENT_SHADER, `
+      precision lowp float;
+      uniform sampler2D tex;
+      varying vec2 uv;
+      void main() { gl_FragColor = texture2D(tex,uv); }`));
 
-let texture = gl.createTexture();
-gl.bindTexture(gl.TEXTURE_2D, texture);
+  gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
+  gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]), gl.STATIC_DRAW);
+  gl.vertexAttribPointer(0, 2, gl.FLOAT, gl.FALSE, 0, 0);
+  gl.enableVertexAttribArray(0);
 
-// Test uploading an image
-const expectedColor = [42, 84, 128, 255];
-const offset = SIZE - 4;
-view.set(expectedColor, offset);
-gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, view, offset);
-wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  let texture = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, texture);
 
-// Test rendering with that image
-gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+  // Test uploading an image
+  const expectedColor = [42, 84, 128, 255];
+  const offset = SIZE - 4;
+  view.set(expectedColor, offset);
+  try {
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, view, offset);
+  } catch (e) {
+    testFailed(`texImage2D from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+
+  // Test rendering with that image
+  gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+
+  // Verify that we rendered what we expected
+  wtu.checkCanvasRect(gl, 0, 0, 1, 1, expectedColor, "texImage2D produced expected color");
+})();
 
-// Verify that we rendered what we expected
-wtu.checkCanvasRect(gl, 0, 0, 1, 1, expectedColor, "texImage2D produced expected color");
 var successfullyParsed = true;
 </script>
 <script src="../../js/js-test-post.js"></script>
diff --git a/sdk/tests/conformance2/wasm/texsubimage2d-16gb-wasm-memory.html b/sdk/tests/conformance2/wasm/texsubimage2d-16gb-wasm-memory.html
index 328d42ec4..7266e88f4 100644
--- a/sdk/tests/conformance2/wasm/texsubimage2d-16gb-wasm-memory.html
+++ b/sdk/tests/conformance2/wasm/texsubimage2d-16gb-wasm-memory.html
@@ -19,66 +19,80 @@
 <script>
 "use strict";
 description(document.title);
-debug("Tests that gl.texSubImage2D() can be called on WebAssembly Memory 16GB in size.");
+debug("Tests that texSubImage2D can be called on the end of a WebAssembly Memory of 16GB in size.");
 debug("");
 let wtu = WebGLTestUtils;
 let gl = wtu.create3DContext("canvas", undefined, 2);
 
 const PAGE = 65536;
 const SIZE = 16*1024*1024*1024;
-let view = new Uint8Array(new WebAssembly.Memory({ index: 'i64', initial: SIZE/PAGE }).buffer);
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ index: 'i64', initial: SIZE / PAGE }).buffer);
+  } catch (e) {
+    testPassed(`Allocating ${SIZE} threw: ${e}`);
+    return;
+  }
 
-function compileShader(type, src) {
-  let shader = gl.createShader(type);
-  gl.shaderSource(shader, src);
-  gl.compileShader(shader);
-  let log = gl.getShaderInfoLog(shader);
-  if (log) debug(log);
-  return shader;
-}
+  function compileShader(type, src) {
+    let shader = gl.createShader(type);
+    gl.shaderSource(shader, src);
+    gl.compileShader(shader);
+    let log = gl.getShaderInfoLog(shader);
+    if (log) debug(log);
+    return shader;
+  }
 
-function createProgram(vs, fs) {
-  let program = gl.createProgram();
-  gl.attachShader(program, vs);
-  gl.attachShader(program, fs);
-  gl.bindAttribLocation(program, 0, 'pos');
-  gl.linkProgram(program);
-  gl.useProgram(program);
-  return program;
-}
+  function createProgram(vs, fs) {
+    let program = gl.createProgram();
+    gl.attachShader(program, vs);
+    gl.attachShader(program, fs);
+    gl.bindAttribLocation(program, 0, 'pos');
+    gl.linkProgram(program);
+    gl.useProgram(program);
+    return program;
+  }
 
-let program = createProgram(
-  compileShader(gl.VERTEX_SHADER, `
-    varying vec2 uv;
-    attribute vec2 pos;
-    void main() { uv = pos; gl_Position = vec4(pos*2.0-vec2(1.0,1.0),0,1); }`),
-  compileShader(gl.FRAGMENT_SHADER, `
-    precision lowp float;
-    uniform sampler2D tex;
-    varying vec2 uv;
-    void main() { gl_FragColor = texture2D(tex,uv); }`));
+  let program = createProgram(
+    compileShader(gl.VERTEX_SHADER, `
+      varying vec2 uv;
+      attribute vec2 pos;
+      void main() { uv = pos; gl_Position = vec4(pos*2.0-vec2(1.0,1.0),0,1); }`),
+    compileShader(gl.FRAGMENT_SHADER, `
+      precision lowp float;
+      uniform sampler2D tex;
+      varying vec2 uv;
+      void main() { gl_FragColor = texture2D(tex,uv); }`));
 
-gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
-gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]), gl.STATIC_DRAW);
-gl.vertexAttribPointer(0, 2, gl.FLOAT, gl.FALSE, 0, 0);
-gl.enableVertexAttribArray(0);
+  gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
+  gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]), gl.STATIC_DRAW);
+  gl.vertexAttribPointer(0, 2, gl.FLOAT, gl.FALSE, 0, 0);
+  gl.enableVertexAttribArray(0);
 
-let texture = gl.createTexture();
-gl.bindTexture(gl.TEXTURE_2D, texture);
+  let texture = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, texture);
 
-// Test uploading an image
-const expectedColor = [42, 84, 128, 255];
-const offset = SIZE - 4;
-view.set(expectedColor, offset);
-gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA8, 1, 1);
-gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, view, offset);
-wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  // Test uploading an image
+  const expectedColor = [42, 84, 128, 255];
+  const offset = SIZE - 4;
+  view.set(expectedColor, offset);
+  gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA8, 1, 1);
+  try {
+    gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, view, offset);
+  } catch (e) {
+    testFailed(`texSubImage2D from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
 
-// Test rendering with that image
-gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+  // Test rendering with that image
+  gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+
+  // Verify that we rendered what we expected
+  wtu.checkCanvasRect(gl, 0, 0, 1, 1, expectedColor, "texSubImage2D produced expected color");
+})();
 
-// Verify that we rendered what we expected
-wtu.checkCanvasRect(gl, 0, 0, 1, 1, expectedColor, "texSubImage2D produced expected color");
 var successfullyParsed = true;
 </script>
 <script src="../../js/js-test-post.js"></script>
diff --git a/sdk/tests/conformance2/wasm/texsubimage2d-2gb-in-4gb-wasm-memory.html b/sdk/tests/conformance2/wasm/texsubimage2d-2gb-in-4gb-wasm-memory.html
new file mode 100644
index 000000000..92901ff6a
--- /dev/null
+++ b/sdk/tests/conformance2/wasm/texsubimage2d-2gb-in-4gb-wasm-memory.html
@@ -0,0 +1,101 @@
+<!--
+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>gl.texSubImage2D() test to Wasm Memory 4GB in size.</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 id="canvas" width="2" height="2" style="width: 40px; height: 40px;"></canvas>
+<div id="description"></div>
+<div id="console"></div>
+<script>
+"use strict";
+description(document.title);
+debug("Tests that texSubImage2D can be called on the end of a ~2GB view into ~4GB of WebAssembly Memory.");
+debug("");
+let wtu = WebGLTestUtils;
+let gl = wtu.create3DContext("canvas", undefined, 2);
+
+const PAGE = 65536;
+const HEAP_SIZE = 4 * 1024 * 1024 * 1024 - PAGE;
+const VIEW_SIZE = 2 * 1024 * 1024 * 1024 - PAGE;
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ initial: HEAP_SIZE / PAGE }).buffer, 0, VIEW_SIZE);
+  } catch (e) {
+    testPassed(`Allocating ${HEAP_SIZE} threw: ${e}`);
+    return;
+  }
+
+  function compileShader(type, src) {
+    let shader = gl.createShader(type);
+    gl.shaderSource(shader, src);
+    gl.compileShader(shader);
+    let log = gl.getShaderInfoLog(shader);
+    if (log) debug(log);
+    return shader;
+  }
+
+  function createProgram(vs, fs) {
+    let program = gl.createProgram();
+    gl.attachShader(program, vs);
+    gl.attachShader(program, fs);
+    gl.bindAttribLocation(program, 0, 'pos');
+    gl.linkProgram(program);
+    gl.useProgram(program);
+    return program;
+  }
+
+  let program = createProgram(
+    compileShader(gl.VERTEX_SHADER, `
+      varying vec2 uv;
+      attribute vec2 pos;
+      void main() { uv = pos; gl_Position = vec4(pos*2.0-vec2(1.0,1.0),0,1); }`),
+    compileShader(gl.FRAGMENT_SHADER, `
+      precision lowp float;
+      uniform sampler2D tex;
+      varying vec2 uv;
+      void main() { gl_FragColor = texture2D(tex,uv); }`));
+
+  gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
+  gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]), gl.STATIC_DRAW);
+  gl.vertexAttribPointer(0, 2, gl.FLOAT, gl.FALSE, 0, 0);
+  gl.enableVertexAttribArray(0);
+
+  let texture = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, texture);
+
+  // Test uploading an image
+  const expectedColor = [42, 84, 128, 255];
+  const offset = view.length - expectedColor.length;
+  view.set(expectedColor, offset);
+  gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA8, 1, 1);
+  try {
+    gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, view, offset);
+  } catch (e) {
+    testFailed(`texSubImage2D from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+
+  // Test rendering with that image
+  gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+
+  // Verify that we rendered what we expected
+  wtu.checkCanvasRect(gl, 0, 0, 1, 1, expectedColor, "texSubImage2D produced expected color");
+})();
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/sdk/tests/conformance2/wasm/texsubimage2d-4gb-wasm-memory.html b/sdk/tests/conformance2/wasm/texsubimage2d-4gb-wasm-memory.html
index d7756629a..4d5ffd1c9 100644
--- a/sdk/tests/conformance2/wasm/texsubimage2d-4gb-wasm-memory.html
+++ b/sdk/tests/conformance2/wasm/texsubimage2d-4gb-wasm-memory.html
@@ -19,66 +19,80 @@
 <script>
 "use strict";
 description(document.title);
-debug("Tests that gl.texSubImage2D() can be called on WebAssembly Memory 4GB in size.");
+debug("Tests that texSubImage2D can be called on the end of a WebAssembly Memory of nearly 4GB in size.");
 debug("");
 let wtu = WebGLTestUtils;
 let gl = wtu.create3DContext("canvas", undefined, 2);
 
 const PAGE = 65536;
 const SIZE = 4*1024*1024*1024 - PAGE; // when uint32_t size is max, we can only reach one page short of full 4GB
-let view = new Uint8Array(new WebAssembly.Memory({ initial: SIZE/PAGE }).buffer);
+(() => {
+  let view;
+  try {
+    view = new Uint8Array(new WebAssembly.Memory({ initial: SIZE / PAGE }).buffer);
+  } catch (e) {
+    testPassed(`Allocating ${SIZE} threw: ${e}`);
+    return;
+  }
 
-function compileShader(type, src) {
-  let shader = gl.createShader(type);
-  gl.shaderSource(shader, src);
-  gl.compileShader(shader);
-  let log = gl.getShaderInfoLog(shader);
-  if (log) debug(log);
-  return shader;
-}
+  function compileShader(type, src) {
+    let shader = gl.createShader(type);
+    gl.shaderSource(shader, src);
+    gl.compileShader(shader);
+    let log = gl.getShaderInfoLog(shader);
+    if (log) debug(log);
+    return shader;
+  }
 
-function createProgram(vs, fs) {
-  let program = gl.createProgram();
-  gl.attachShader(program, vs);
-  gl.attachShader(program, fs);
-  gl.bindAttribLocation(program, 0, 'pos');
-  gl.linkProgram(program);
-  gl.useProgram(program);
-  return program;
-}
+  function createProgram(vs, fs) {
+    let program = gl.createProgram();
+    gl.attachShader(program, vs);
+    gl.attachShader(program, fs);
+    gl.bindAttribLocation(program, 0, 'pos');
+    gl.linkProgram(program);
+    gl.useProgram(program);
+    return program;
+  }
 
-let program = createProgram(
-  compileShader(gl.VERTEX_SHADER, `
-    varying vec2 uv;
-    attribute vec2 pos;
-    void main() { uv = pos; gl_Position = vec4(pos*2.0-vec2(1.0,1.0),0,1); }`),
-  compileShader(gl.FRAGMENT_SHADER, `
-    precision lowp float;
-    uniform sampler2D tex;
-    varying vec2 uv;
-    void main() { gl_FragColor = texture2D(tex,uv); }`));
+  let program = createProgram(
+    compileShader(gl.VERTEX_SHADER, `
+      varying vec2 uv;
+      attribute vec2 pos;
+      void main() { uv = pos; gl_Position = vec4(pos*2.0-vec2(1.0,1.0),0,1); }`),
+    compileShader(gl.FRAGMENT_SHADER, `
+      precision lowp float;
+      uniform sampler2D tex;
+      varying vec2 uv;
+      void main() { gl_FragColor = texture2D(tex,uv); }`));
 
-gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
-gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]), gl.STATIC_DRAW);
-gl.vertexAttribPointer(0, 2, gl.FLOAT, gl.FALSE, 0, 0);
-gl.enableVertexAttribArray(0);
+  gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
+  gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]), gl.STATIC_DRAW);
+  gl.vertexAttribPointer(0, 2, gl.FLOAT, gl.FALSE, 0, 0);
+  gl.enableVertexAttribArray(0);
 
-let texture = gl.createTexture();
-gl.bindTexture(gl.TEXTURE_2D, texture);
+  let texture = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, texture);
 
-// Test uploading an image
-const expectedColor = [42, 84, 128, 255];
-const offset = SIZE - 4;
-view.set(expectedColor, offset);
-gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA8, 1, 1);
-gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, view, offset);
-wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+  // Test uploading an image
+  const expectedColor = [42, 84, 128, 255];
+  const offset = SIZE - 4;
+  view.set(expectedColor, offset);
+  gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA8, 1, 1);
+  try {
+    gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, view, offset);
+  } catch (e) {
+    testFailed(`texSubImage2D from ${view.length} byte view threw: ${e}`);
+    return;
+  }
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
 
-// Test rendering with that image
-gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+  // Test rendering with that image
+  gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+
+  // Verify that we rendered what we expected
+  wtu.checkCanvasRect(gl, 0, 0, 1, 1, expectedColor, "texSubImage2D produced expected color");
+})();
 
-// Verify that we rendered what we expected
-wtu.checkCanvasRect(gl, 0, 0, 1, 1, expectedColor, "texSubImage2D produced expected color");
 var successfullyParsed = true;
 </script>
 <script src="../../js/js-test-post.js"></script>