@luma.gl/test-utils 9.0.0-beta.4 → 9.0.0-beta.5

package/dist/test-runner.js

@@ -1,172 +1,199 @@
-import { webglDevice } from "./create-test-device.js";
-import { ClassicAnimationLoop as AnimationLoop } from "./engine/classic-animation-loop.js";
+// @ts-nocheck
+/* eslint-disable */
+import { webglDevice } from './create-test-device';
+// TODO - Replace with new AnimationLoop from `@luma.gl/engine`
+import { ClassicAnimationLoop as AnimationLoop } from './engine/classic-animation-loop';
 const DEFAULT_TEST_CASE = {
-  name: 'Unnamed test',
-  onInitialize: async () => {},
-  onRender: _ref => {
-    let {
-      done
-    } = _ref;
-    return done();
-  },
-  onFinalize: () => {}
+    name: 'Unnamed test',
+    onInitialize: async () => { },
+    onRender: ({ done }) => done(),
+    onFinalize: () => { }
 };
 const DEFAULT_TEST_PROPS = {
-  width: undefined,
-  height: undefined,
-  onTestStart: testCase => console.log(`# ${testCase.name}`),
-  onTestPass: (testCase, result) => console.log(`ok ${testCase.name} passed`),
-  onTestFail: (testCase, error) => console.log(`not ok ${testCase.name} failed`),
-  timeout: 2000,
-  maxFramesToRender: undefined,
-  imageDiffOptions: undefined
+    width: undefined,
+    height: undefined,
+    // test lifecycle callback
+    onTestStart: (testCase) => console.log(`# ${testCase.name}`),
+    onTestPass: (testCase, result) => console.log(`ok ${testCase.name} passed`),
+    onTestFail: (testCase, error) => console.log(`not ok ${testCase.name} failed`),
+    // milliseconds to wait for each test case before aborting
+    timeout: 2000,
+    maxFramesToRender: undefined,
+    imageDiffOptions: undefined
 };
+/** Runs an array of test cases */
 export class TestRunner {
-  constructor() {
-    let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    this.device = webglDevice;
-    this.props = void 0;
-    this.isRunning = false;
-    this.testOptions = {
-      ...DEFAULT_TEST_PROPS
-    };
-    this._animationProps = void 0;
-    this._animationLoop = void 0;
-    this._testCases = [];
-    this._testCaseData = null;
-    this._currentTestCase = void 0;
-    this._currentTestCaseStartTime = void 0;
-    this._currentTestCaseStartTick = void 0;
-    this.isDiffing = false;
-    this.isHeadless = Boolean(window.browserTestDriver_isHeadless);
-    this.props = props;
-  }
-  add(testCases) {
-    if (!Array.isArray(testCases)) {
-      testCases = [testCases];
+    device = webglDevice;
+    props;
+    isRunning = false;
+    testOptions = { ...DEFAULT_TEST_PROPS };
+    _animationProps;
+    _animationLoop;
+    _testCases = [];
+    _testCaseData = null;
+    _currentTestCase;
+    _currentTestCaseStartTime;
+    _currentTestCaseStartTick;
+    // should be defined in snapshot-test-runner
+    isDiffing = false;
+    // @ts-expect-error
+    isHeadless = Boolean(window.browserTestDriver_isHeadless);
+    /**
+     * props
+     *   AnimationLoop props
+     */
+    constructor(props = {}) {
+        this.props = props;
     }
-    for (const testCase of testCases) {
-      this._testCases.push(testCase);
+    /**
+     * Add testCase(s)
+     */
+    add(testCases) {
+        if (!Array.isArray(testCases)) {
+            testCases = [testCases];
+        }
+        for (const testCase of testCases) {
+            this._testCases.push(testCase);
+        }
+        return this;
+    }
+    /**
+      * Returns a promise that resolves when all the test cases are done
+      */
+    run(options = {}) {
+        this.testOptions = { ...this.testOptions, ...options };
+        return new Promise((resolve, reject) => {
+            this._animationLoop = new AnimationLoop({
+                ...this.props,
+                device: this.device,
+                onRender: this._onRender.bind(this),
+                onFinalize: () => {
+                    this.isRunning = false;
+                    resolve();
+                }
+            });
+            this._animationLoop.start(this.props);
+            this.isRunning = true;
+            this.isDiffing = false;
+            this._currentTestCase = null;
+        }).catch(error => {
+            this._fail({ error: error.message });
+            // reject(error);
+        });
     }
-    return this;
-  }
-  run() {
-    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    this.testOptions = {
-      ...this.testOptions,
-      ...options
-    };
-    return new Promise((resolve, reject) => {
-      this._animationLoop = new AnimationLoop({
-        ...this.props,
-        device: this.device,
-        onRender: this._onRender.bind(this),
-        onFinalize: () => {
-          this.isRunning = false;
-          resolve();
+    /* Lifecycle methods for subclassing */
+    initTestCase(testCase) {
+        const { animationLoop } = testCase;
+        if (animationLoop) {
+            testCase.onInitialize = animationLoop.props.onInitialize.bind(animationLoop);
+            testCase.onRender = animationLoop.props.onRender.bind(animationLoop);
+            testCase.onFinalize = animationLoop.props.onFinalize.bind(animationLoop);
+        }
+        for (const key in DEFAULT_TEST_CASE) {
+            testCase[key] = testCase[key] || DEFAULT_TEST_CASE[key];
         }
-      });
-      this._animationLoop.start(this.props);
-      this.isRunning = true;
-      this.isDiffing = false;
-      this._currentTestCase = null;
-    }).catch(error => {
-      this._fail({
-        error: error.message
-      });
-    });
-  }
-  initTestCase(testCase) {
-    const {
-      animationLoop
-    } = testCase;
-    if (animationLoop) {
-      testCase.onInitialize = animationLoop.props.onInitialize.bind(animationLoop);
-      testCase.onRender = animationLoop.props.onRender.bind(animationLoop);
-      testCase.onFinalize = animationLoop.props.onFinalize.bind(animationLoop);
     }
-    for (const key in DEFAULT_TEST_CASE) {
-      testCase[key] = testCase[key] || DEFAULT_TEST_CASE[key];
+    shouldRender(animationProps) {
+        return true;
     }
-  }
-  shouldRender(animationProps) {
-    return true;
-  }
-  assert(testCase) {
-    this._pass(testCase);
-    this._next();
-  }
-  _pass(result) {
-    this.testOptions.onTestPass(this._currentTestCase, result);
-  }
-  _fail(result) {
-    this.testOptions.onTestFail(this._currentTestCase, result);
-  }
-  _next() {
-    this._nextTestCase();
-  }
-  _onRender(animationProps) {
-    this._animationProps = animationProps;
-    const testCase = this._currentTestCase || this._nextTestCase();
-    if (!testCase) {
-      this._animationLoop.stop();
-      return;
+    assert(testCase) {
+        this._pass(testCase);
+        this._next();
     }
-    let isDone = false;
-    const testCaseAnimationProps = {
-      ...animationProps,
-      ...this._testCaseData,
-      startTime: this._currentTestCaseStartTime,
-      time: animationProps.time - this._currentTestCaseStartTime,
-      tick: animationProps.tick - this._currentTestCaseStartTick,
-      done: () => {
-        isDone = true;
-      }
-    };
-    if (this._testCaseData && this.shouldRender(testCaseAnimationProps)) {
-      testCase.onRender(testCaseAnimationProps);
+    /* Utilities */
+    _pass(result) {
+        this.testOptions.onTestPass(this._currentTestCase, result);
+        // this._animationLoop?.stop();
     }
-    const timeout = testCase.timeout || this.testOptions.timeout;
-    if (timeout && testCaseAnimationProps.time > timeout) {
-      isDone = true;
+    _fail(result) {
+        this.testOptions.onTestFail(this._currentTestCase, result);
+        // this._animationLoop?.stop();
     }
-    if (isDone) {
-      this.assert(testCase);
+    _next() {
+        this._nextTestCase();
     }
-  }
-  _nextTestCase() {
-    const animationProps = this._animationProps;
-    if (this._testCaseData) {
-      for (const key in this._testCaseData) {
-        const value = this._testCaseData[key];
-        if (value && value.delete) {
-          value.destroy();
+    /* Private methods */
+    _onRender(animationProps) {
+        this._animationProps = animationProps;
+        const testCase = this._currentTestCase || this._nextTestCase();
+        if (!testCase) {
+            // all test cases are done
+            this._animationLoop.stop();
+            return;
+        }
+        let isDone = false;
+        const testCaseAnimationProps = {
+            ...animationProps,
+            ...this._testCaseData,
+            // tick/time starts from 0 for each test case
+            startTime: this._currentTestCaseStartTime,
+            time: animationProps.time - this._currentTestCaseStartTime,
+            tick: animationProps.tick - this._currentTestCaseStartTick,
+            // called by the test case when it is done rendering and ready for capture and diff
+            done: () => {
+                isDone = true;
+            }
+        };
+        if (this._testCaseData && this.shouldRender(testCaseAnimationProps)) {
+            // try {
+            // test case is initialized, render frame
+            testCase.onRender(testCaseAnimationProps);
+            // } catch {
+            //   isDone = true;
+            // }
+        }
+        const timeout = testCase.timeout || this.testOptions.timeout;
+        if (timeout && testCaseAnimationProps.time > timeout) {
+            isDone = true;
+        }
+        if (isDone) {
+            this.assert(testCase);
         }
-      }
-      this._currentTestCase.onFinalize(Object.assign({}, animationProps, this._testCaseData));
-      this.device.popState();
-      this._currentTestCase = null;
-      this._testCaseData = null;
     }
-    const testCase = this._testCases.shift();
-    if (testCase) {
-      this._currentTestCase = testCase;
-      this._currentTestCaseStartTime = animationProps.time;
-      this._currentTestCaseStartTick = animationProps.tick;
-      this.initTestCase(testCase);
-      this.device.pushState();
-      const initProps = {
-        ...animationProps,
-        startTime: animationProps.time,
-        time: 0,
-        tick: 0
-      };
-      Promise.resolve(testCase.onInitialize(initProps)).then(userData => {
-        this._testCaseData = userData || {};
-      });
-      this.testOptions.onTestStart(testCase);
+    _nextTestCase() {
+        const animationProps = this._animationProps;
+        // finalize the current test case
+        if (this._testCaseData) {
+            for (const key in this._testCaseData) {
+                const value = this._testCaseData[key];
+                if (value && value.delete) {
+                    value.destroy();
+                }
+            }
+            this._currentTestCase.onFinalize(Object.assign({}, animationProps, this._testCaseData));
+            // reset WebGL context
+            this.device.popState();
+            this._currentTestCase = null;
+            this._testCaseData = null;
+        }
+        // get the next test case
+        const testCase = this._testCases.shift();
+        if (testCase) {
+            // start new test case
+            this._currentTestCase = testCase;
+            this._currentTestCaseStartTime = animationProps.time;
+            this._currentTestCaseStartTick = animationProps.tick;
+            this.initTestCase(testCase);
+            // initialize test case
+            // save WebGL context
+            this.device.pushState();
+            // aligned with the behavior of AnimationLoop.onInitialized
+            // onInitialized could return a plain object or a promise
+            const initProps = {
+                ...animationProps,
+                // tick/time starts from 0 for each test case
+                startTime: animationProps.time,
+                time: 0,
+                tick: 0
+            };
+            // aligned with the behavior of AnimationLoop.onInitialized
+            // onInitialized could return a plain object or a promise
+            Promise.resolve(testCase.onInitialize(initProps)).then((userData) => {
+                this._testCaseData = userData || {};
+            });
+            // invoke user callback
+            this.testOptions.onTestStart(testCase);
+        }
+        return testCase;
     }
-    return testCase;
-  }
 }
-//# sourceMappingURL=test-runner.js.map

package/dist/utils/check-type.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tests that an argument matches the type.
+ * @note fails during typescript type check, not during runtime.
+ */
+export declare function checkType<T>(value: T): void;
+//# sourceMappingURL=check-type.d.ts.map

package/dist/utils/check-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-type.d.ts","sourceRoot":"","sources":["../../src/utils/check-type.ts"],"names":[],"mappings":"AACA;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAG"}

package/dist/utils/check-type.js

@@ -0,0 +1,5 @@
+/**
+ * Tests that an argument matches the type.
+ * @note fails during typescript type check, not during runtime.
+ */
+export function checkType(value) { }

package/dist/utils/deep-copy.d.ts

@@ -0,0 +1,3 @@
+/** Recursively copies objects */
+export declare function deepCopy(object: Record<string, any>): any;
+//# sourceMappingURL=deep-copy.d.ts.map

package/dist/utils/deep-copy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-copy.d.ts","sourceRoot":"","sources":["../../src/utils/deep-copy.ts"],"names":[],"mappings":"AAAA,iCAAiC;AACjC,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,OAcnD"}

package/dist/utils/deep-copy.js

@@ -0,0 +1,14 @@
+/** Recursively copies objects */
+export function deepCopy(object) {
+    if (Array.isArray(object)) {
+        return object.map((element) => deepCopy(element));
+    }
+    if (object !== null && typeof object === 'object') {
+        const newObject = {};
+        for (const key in object) {
+            newObject[key] = deepCopy(object[key]);
+        }
+        return newObject;
+    }
+    return object;
+}

package/dist/utils/get-bounding-box.d.ts

@@ -0,0 +1,7 @@
+export declare function getBoundingBoxInPage(domElement: HTMLElement): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+//# sourceMappingURL=get-bounding-box.d.ts.map

package/dist/utils/get-bounding-box.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-bounding-box.d.ts","sourceRoot":"","sources":["../../src/utils/get-bounding-box.ts"],"names":[],"mappings":"AACA,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,WAAW,GAAG;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;CAAC,CAQpH"}

package/dist/utils/get-bounding-box.js

@@ -0,0 +1,10 @@
+// Get the bounding box of a DOMElement relative to the page
+export function getBoundingBoxInPage(domElement) {
+    const bbox = domElement.getBoundingClientRect();
+    return {
+        x: window.scrollX + bbox.x,
+        y: window.scrollY + bbox.y,
+        width: bbox.width,
+        height: bbox.height
+    };
+}

package/dist/utils/resource-tracker.d.ts

@@ -0,0 +1,6 @@
+export declare function getResourceCounts(): {
+    Texture2D: any;
+    Buffer: any;
+};
+export declare function getLeakedResources(startCounts: Record<string, number>, endCounts: Record<string, number>): number | null;
+//# sourceMappingURL=resource-tracker.d.ts.map

package/dist/utils/resource-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-tracker.d.ts","sourceRoot":"","sources":["../../src/utils/resource-tracker.ts"],"names":[],"mappings":"AACA,wBAAgB,iBAAiB;;;EAOhC;AAED,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI,CAaxH"}

package/dist/utils/resource-tracker.js

@@ -0,0 +1,23 @@
+/* global luma */
+export function getResourceCounts() {
+    // @ts-ignore
+    const resourceStats = luma.stats.get('Resource Counts');
+    return {
+        Texture2D: resourceStats.get('Texture2Ds Active').count,
+        Buffer: resourceStats.get('Buffers Active').count
+    };
+}
+export function getLeakedResources(startCounts, endCounts) {
+    let leakedResources = null;
+    const info = 'leaking: ';
+    for (const resourceName in endCounts) {
+        const leakCount = endCounts[resourceName] - startCounts[resourceName];
+        if (leakCount !== 0) {
+            leakedResources = Object.assign({}, leakedResources, {
+                [resourceName]: leakCount,
+                info: `${info} ${resourceName}: ${leakCount}, `
+            });
+        }
+    }
+    return leakedResources;
+}

package/dist/utils.js

@@ -1,10 +1,10 @@
+// Get the bounding box of a DOMElement relative to the page
 export function getBoundingBoxInPage(domElement) {
-  const bbox = domElement.getBoundingClientRect();
-  return {
-    x: window.scrollX + bbox.x,
-    y: window.scrollY + bbox.y,
-    width: bbox.width,
-    height: bbox.height
-  };
+    const bbox = domElement.getBoundingClientRect();
+    return {
+        x: window.scrollX + bbox.x,
+        y: window.scrollY + bbox.y,
+        width: bbox.width,
+        height: bbox.height
+    };
 }
-//# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/test-utils",
-  "version": "9.0.0-beta.4",
+  "version": "9.0.0-beta.5",
   "description": "Automated WebGL testing utilities with Puppeteer and image diffing",
   "type": "module",
   "license": "MIT",
@@ -12,10 +12,10 @@
     "url": "https://github.com/visgl/luma.gl"
   },
   "keywords": [
-    "webgl2",
+    "webgpu",
     "webgl",
     "automation",
-    "testing"
+    "test"
   ],
   "types": "dist/index.d.ts",
   "main": "dist/index.cjs",
@@ -32,32 +32,24 @@
     "dist",
     "README.md"
   ],
-  "browser": {
-    "gl": false
-  },
   "scripts": {
     "pre-build": "echo test utils has no bundle"
   },
-  "dependencies": {
-    "@luma.gl/core": "9.0.0-beta.4",
-    "@luma.gl/engine": "9.0.0-beta.4",
-    "@luma.gl/webgl": "9.0.0-beta.4",
-    "@luma.gl/webgpu": "9.0.0-beta.4",
-    "@probe.gl/env": "^4.0.2",
-    "@types/gl": "^6.0.2",
-    "gl": "^6.0.1"
-  },
   "peerDependencies": {
-    "@luma.gl/core": "9.0.0-beta.1",
-    "@luma.gl/webgl": "9.0.0-beta.1",
-    "@luma.gl/webgpu": "9.0.0-beta.1",
-    "@probe.gl/test-utils": "^4.0.2"
+    "@luma.gl/core": "^9.0.0-beta.4",
+    "@luma.gl/engine": "^9.0.0-beta.4",
+    "@luma.gl/shadertools": "^9.0.0-beta.4",
+    "@luma.gl/webgl": "^9.0.0-beta.4",
+    "@luma.gl/webgpu": "^9.0.0-beta.4"
+  },
+  "devDependencies": {
+    "@luma.gl/core": "9.0.0-beta.5",
+    "@luma.gl/engine": "9.0.0-beta.5",
+    "@luma.gl/webgl": "9.0.0-beta.5",
+    "@luma.gl/webgpu": "9.0.0-beta.5"
   },
-  "engines_comment": [
-    "gl needs recent minor version of Node 16.x"
-  ],
-  "engines": {
-    "node": ">=16.18.0"
+  "dependencies": {
+    "@probe.gl/env": "^4.0.2"
   },
-  "gitHead": "bf6bb45b25d59de5b3d05dab4b2e91ad583059e6"
+  "gitHead": "793d3ab42f5a572b6cb603ea78aabaa73a873301"
 }

package/src/create-test-device.ts

@@ -13,7 +13,7 @@ const CONTEXT_DEFAULTS: Partial<DeviceProps> = {
 };
 
 /** Create a test WebGL context */
-export function createTestContext(opts: Record<string, any> = {}): WebGLRenderingContext | null {
+export function createTestContext(opts: Record<string, any> = {}): WebGL2RenderingContext | null {
   const device = createTestDevice(opts);
   return device && device.gl;
 }
@@ -31,12 +31,8 @@ export function createTestDevice(props: DeviceProps = {}): WebGLDevice | null {
   }
 }
 
-/** A WebGL 1 Device intended for testing */
-export const webgl1Device: WebGLDevice = createTestDevice({id: 'webgl1-test-device', webgl1: true, webgl2: false}) ;
-/** A WebGL 2 Device intended for testing. Can be null */
-export const webgl2Device: WebGLDevice = createTestDevice({id: 'webgl2-test-device', webgl1: false, webgl2: true}) ;
-/** A WebGL 2 or WebGL 1 Device intended for testing. Best available. */
-export const webglDevice: WebGLDevice = webgl2Device || webgl1Device;
+/** A WebGL 2 Device intended for testing */
+export const webglDevice: WebGLDevice = createTestDevice({id: 'webgl2-test-device'}) ;
 
 /** Only available after getTestDevices() has completed */
 export let webgpuDevice: WebGPUDevice;
@@ -46,12 +42,7 @@ let webgpuCreated = false;
 /** Synchronously get test devices (only WebGLDevices) */
 export function getWebGLTestDevices(): WebGLDevice[] {
   const devices: WebGLDevice[] = [];
-  if (webgl2Device) {
-    devices.push(webgl2Device);
-  }
-  if (webgl1Device) {
-    devices.push(webgl1Device);
-  }
+  devices.push(webglDevice);
   return devices;
 }
 

package/src/engine/classic-animation-loop.ts

@@ -12,7 +12,7 @@ import {Timeline, AnimationProps} from '@luma.gl/engine';
 import {Stats, Stat} from '@probe.gl/stats';
 import {isBrowser} from '@probe.gl/env';
 
-import {isWebGL, resetGLParameters} from '@luma.gl/webgl';
+import {resetGLParameters} from '@luma.gl/webgl';
 // import {default as Query} from '../classic/query';
 // import {ClassicFramebuffer} from '../classic/framebuffer';
 
@@ -41,7 +41,7 @@ export type ClassicAnimationProps = AnimationProps & {
   stop: () => ClassicAnimationLoop;
 
   /** @deprecated Use .device */
-  gl: WebGLRenderingContext;
+  gl: WebGL2RenderingContext;
   /** @deprecated Will be removed */
   framebuffer: unknown;
 
@@ -56,7 +56,7 @@ export type ClassicAnimationProps = AnimationProps & {
 /** ClassicAnimationLoop properties */
 export type ClassicAnimationLoopProps = {
   onCreateDevice?: (props: DeviceProps) => Promise<Device>;
-  onCreateContext?: (props: ContextProps) => WebGLRenderingContext; // TODO: signature from createGLContext
+  onCreateContext?: (props: ContextProps) => WebGL2RenderingContext; // TODO: signature from createGLContext
   onAddHTML?: (div: HTMLDivElement) => string; // innerHTML
   onInitialize?: (animationProps: ClassicAnimationProps) => {} | void | Promise<{} | void>;
   onRender?: (animationProps: ClassicAnimationProps) => void;
@@ -75,7 +75,7 @@ export type ClassicAnimationLoopProps = {
   useDevicePixels?: number | boolean;
 
   /** @deprecated Use .device */
-  gl?: WebGLRenderingContext | null;
+  gl?: WebGL2RenderingContext | null;
   /** @deprecated Will be removed */
   createFramebuffer?: boolean;
 };
@@ -137,7 +137,7 @@ export class ClassicAnimationLoop {
   // _gpuTimeQuery: Query | null = null;
 
   /** @deprecated */
-  gl: WebGLRenderingContext;
+  gl: WebGL2RenderingContext;
 
   /*
    */
@@ -575,10 +575,6 @@ export class ClassicAnimationLoop {
     // @ts-expect-error
     this.gl = this.device.gl;
 
-    if (!isWebGL(this.gl)) {
-      throw new Error('ClassicAnimationLoop.onCreateContext - illegal context returned');
-    }
-
     // Reset the WebGL context.
     resetGLParameters(this.gl);
 

package/src/index.ts

@@ -1,11 +1,18 @@
 import './register-devices';
 
+// TEST RUNNERS
 export type {TestRunnerTestCase} from './test-runner';
 export type {SnapshotTestRunnerTestCase} from './snapshot-test-runner';
 
 export {SnapshotTestRunner} from './snapshot-test-runner';
 export {PerformanceTestRunner} from './performance-test-runner';
-export {createTestDevice, createTestContext, webgl1Device, webgl2Device, webgpuDevice} from './create-test-device';
+
+// TEST DEVICES
+export {webglDevice, webgpuDevice} from './create-test-device';
 export {getTestDevices, getWebGLTestDevices} from './create-test-device';
+export {createTestDevice, createTestContext} from './create-test-device';
 
-export {checkType} from './check-type';
+// UTILS
+export {checkType} from './utils/check-type';
+export {deepCopy} from './utils/deep-copy';
+export {getResourceCounts, getLeakedResources} from './utils/resource-tracker';