@gjsify/webgl 0.1.2 → 0.1.4

package/lib/esm/conformance/context.spec.js

@@ -0,0 +1,302 @@
+import { describe, it, expect, beforeEach, on } from "@gjsify/unit";
+import { WebGLRenderingContext as OurWebGLRenderingContext } from "@gjsify/webgl";
+import { createGLSetup } from "./setup.js";
+const WEBGL_METHODS = [
+  "getContextAttributes",
+  "activeTexture",
+  "attachShader",
+  "bindAttribLocation",
+  "bindBuffer",
+  "bindFramebuffer",
+  "bindRenderbuffer",
+  "bindTexture",
+  "blendColor",
+  "blendEquation",
+  "blendEquationSeparate",
+  "blendFunc",
+  "blendFuncSeparate",
+  "bufferData",
+  "bufferSubData",
+  "checkFramebufferStatus",
+  "clear",
+  "clearColor",
+  "clearDepth",
+  "clearStencil",
+  "colorMask",
+  "compileShader",
+  "compressedTexImage2D",
+  "compressedTexSubImage2D",
+  "copyTexImage2D",
+  "copyTexSubImage2D",
+  "createBuffer",
+  "createFramebuffer",
+  "createProgram",
+  "createRenderbuffer",
+  "createShader",
+  "createTexture",
+  "cullFace",
+  "deleteBuffer",
+  "deleteFramebuffer",
+  "deleteProgram",
+  "deleteRenderbuffer",
+  "deleteShader",
+  "deleteTexture",
+  "depthFunc",
+  "depthMask",
+  "depthRange",
+  "detachShader",
+  "disable",
+  "disableVertexAttribArray",
+  "drawArrays",
+  "drawElements",
+  "enable",
+  "enableVertexAttribArray",
+  "finish",
+  "flush",
+  "framebufferRenderbuffer",
+  "framebufferTexture2D",
+  "frontFace",
+  "generateMipmap",
+  "getActiveAttrib",
+  "getActiveUniform",
+  "getAttachedShaders",
+  "getAttribLocation",
+  "getParameter",
+  "getBufferParameter",
+  "getError",
+  "getExtension",
+  "getFramebufferAttachmentParameter",
+  "getProgramParameter",
+  "getProgramInfoLog",
+  "getRenderbufferParameter",
+  "getShaderParameter",
+  "getShaderInfoLog",
+  "getShaderPrecisionFormat",
+  "getShaderSource",
+  "getSupportedExtensions",
+  "getTexParameter",
+  "getUniform",
+  "getUniformLocation",
+  "getVertexAttrib",
+  "getVertexAttribOffset",
+  "hint",
+  "isBuffer",
+  "isContextLost",
+  "isEnabled",
+  "isFramebuffer",
+  "isProgram",
+  "isRenderbuffer",
+  "isShader",
+  "isTexture",
+  "lineWidth",
+  "linkProgram",
+  "pixelStorei",
+  "polygonOffset",
+  "readPixels",
+  "renderbufferStorage",
+  "sampleCoverage",
+  "scissor",
+  "shaderSource",
+  "stencilFunc",
+  "stencilFuncSeparate",
+  "stencilMask",
+  "stencilMaskSeparate",
+  "stencilOp",
+  "stencilOpSeparate",
+  "texImage2D",
+  "texParameterf",
+  "texParameteri",
+  "texSubImage2D",
+  "uniform1f",
+  "uniform1fv",
+  "uniform1i",
+  "uniform1iv",
+  "uniform2f",
+  "uniform2fv",
+  "uniform2i",
+  "uniform2iv",
+  "uniform3f",
+  "uniform3fv",
+  "uniform3i",
+  "uniform3iv",
+  "uniform4f",
+  "uniform4fv",
+  "uniform4i",
+  "uniform4iv",
+  "uniformMatrix2fv",
+  "uniformMatrix3fv",
+  "uniformMatrix4fv",
+  "useProgram",
+  "validateProgram",
+  "vertexAttrib1f",
+  "vertexAttrib1fv",
+  "vertexAttrib2f",
+  "vertexAttrib2fv",
+  "vertexAttrib3f",
+  "vertexAttrib3fv",
+  "vertexAttrib4f",
+  "vertexAttrib4fv",
+  "vertexAttribPointer",
+  "viewport"
+];
+const WEBGL_CONSTANTS = [
+  ["DEPTH_BUFFER_BIT", 256],
+  ["STENCIL_BUFFER_BIT", 1024],
+  ["COLOR_BUFFER_BIT", 16384],
+  ["POINTS", 0],
+  ["LINES", 1],
+  ["LINE_LOOP", 2],
+  ["LINE_STRIP", 3],
+  ["TRIANGLES", 4],
+  ["TRIANGLE_STRIP", 5],
+  ["TRIANGLE_FAN", 6],
+  ["ZERO", 0],
+  ["ONE", 1],
+  ["SRC_COLOR", 768],
+  ["SRC_ALPHA", 770],
+  ["FUNC_ADD", 32774],
+  ["ARRAY_BUFFER", 34962],
+  ["ELEMENT_ARRAY_BUFFER", 34963],
+  ["STREAM_DRAW", 35040],
+  ["STATIC_DRAW", 35044],
+  ["DYNAMIC_DRAW", 35048],
+  ["FRAGMENT_SHADER", 35632],
+  ["VERTEX_SHADER", 35633],
+  ["COMPILE_STATUS", 35713],
+  ["LINK_STATUS", 35714],
+  ["VALIDATE_STATUS", 35715],
+  ["FLOAT", 5126],
+  ["FLOAT_VEC2", 35664],
+  ["FLOAT_VEC3", 35665],
+  ["FLOAT_VEC4", 35666],
+  ["FLOAT_MAT2", 35674],
+  ["FLOAT_MAT3", 35675],
+  ["FLOAT_MAT4", 35676],
+  ["INT", 5124],
+  ["TEXTURE_2D", 3553],
+  ["TEXTURE_CUBE_MAP", 34067],
+  ["RGBA", 6408],
+  ["RGB", 6407],
+  ["UNSIGNED_BYTE", 5121],
+  ["UNSIGNED_SHORT", 5123],
+  ["UNSIGNED_INT", 5125],
+  ["FRAMEBUFFER", 36160],
+  ["RENDERBUFFER", 36161],
+  ["DEPTH_COMPONENT16", 33189],
+  ["DEPTH_ATTACHMENT", 36096],
+  ["COLOR_ATTACHMENT0", 36064],
+  ["FRAMEBUFFER_COMPLETE", 36053],
+  ["NO_ERROR", 0],
+  ["INVALID_ENUM", 1280],
+  ["INVALID_VALUE", 1281],
+  ["INVALID_OPERATION", 1282],
+  ["OUT_OF_MEMORY", 1285]
+];
+var context_spec_default = async () => {
+  await on("Display", async () => {
+    const setup = createGLSetup();
+    if (!setup) {
+      console.warn("WebGL context not available \u2014 skipping conformance/context tests");
+      return;
+    }
+    const { gl, glArea, win } = setup;
+    glArea.make_current();
+    await describe("conformance/context/methods: all WebGL methods present", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("all standard WebGL methods are functions on the context", async () => {
+        const missing = [];
+        for (const method of WEBGL_METHODS) {
+          if (typeof gl[method] !== "function") {
+            missing.push(method);
+          }
+        }
+        if (missing.length > 0) {
+          throw new Error(`Missing WebGL methods: ${missing.join(", ")}`);
+        }
+      });
+    });
+    await describe("conformance/context/constants-and-properties: constant values", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("all sampled WebGL constants have the correct numeric value", async () => {
+        const wrong = [];
+        for (const [name, expected] of WEBGL_CONSTANTS) {
+          const actual = gl[name];
+          if (actual !== expected) {
+            wrong.push(`${name}: expected ${expected}, got ${actual}`);
+          }
+        }
+        if (wrong.length > 0) {
+          throw new Error(`Wrong constant values:
+${wrong.join("\n")}`);
+        }
+      });
+      await it("WebGLRenderingContext class constant values match instance constants", async () => {
+        const wrong = [];
+        for (const [name, expected] of WEBGL_CONSTANTS) {
+          const classVal = OurWebGLRenderingContext[name];
+          if (classVal !== void 0 && classVal !== expected) {
+            wrong.push(`${name}: expected ${expected}, got ${classVal}`);
+          }
+        }
+        if (wrong.length > 0) {
+          throw new Error(`Wrong class constant values:
+${wrong.join("\n")}`);
+        }
+      });
+    });
+    await describe("conformance/context/context-type-test", async () => {
+      beforeEach(async () => {
+        glArea.make_current();
+      });
+      await it("WebGLRenderingContext should exist in globalThis", async () => {
+        expect(typeof globalThis.WebGLRenderingContext !== "undefined").toBeTruthy();
+      });
+      await it("gl should be an instance of WebGLRenderingContext", async () => {
+        expect(gl instanceof OurWebGLRenderingContext).toBeTruthy();
+      });
+      await it("getContextAttributes returns an object", async () => {
+        const attrs = gl.getContextAttributes();
+        expect(attrs).not.toBeNull();
+        expect(typeof attrs).toBe("object");
+      });
+      await it("isContextLost returns false initially", async () => {
+        expect(gl.isContextLost()).toBe(false);
+      });
+      await it("canvas property points to the HTMLCanvasElement", async () => {
+        expect(gl.canvas).not.toBeNull();
+        expect(typeof gl.canvas.getContext).toBe("function");
+      });
+      await it("drawingBufferWidth and drawingBufferHeight are positive integers", async () => {
+        expect(gl.drawingBufferWidth).toBeGreaterThan(0);
+        expect(gl.drawingBufferHeight).toBeGreaterThan(0);
+        expect(Number.isInteger(gl.drawingBufferWidth)).toBeTruthy();
+        expect(Number.isInteger(gl.drawingBufferHeight)).toBeTruthy();
+      });
+      await it("getSupportedExtensions returns an array of strings", async () => {
+        const exts = gl.getSupportedExtensions();
+        expect(Array.isArray(exts)).toBeTruthy();
+        for (const ext of exts) {
+          expect(typeof ext).toBe("string");
+        }
+      });
+      await it("getParameter(VENDOR) and getParameter(RENDERER) return strings", async () => {
+        const vendor = gl.getParameter(gl.VENDOR);
+        const renderer = gl.getParameter(gl.RENDERER);
+        const version = gl.getParameter(gl.VERSION);
+        const shadingLang = gl.getParameter(gl.SHADING_LANGUAGE_VERSION);
+        expect(typeof vendor).toBe("string");
+        expect(typeof renderer).toBe("string");
+        expect(typeof version).toBe("string");
+        expect(typeof shadingLang).toBe("string");
+      });
+    });
+    win.destroy();
+  });
+};
+export {
+  context_spec_default as default
+};