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>