@thumbmarkjs/thumbmarkjs 1.9.0 → 1.10.0

package/src/components/intl/index.test.ts

@@ -1,124 +0,0 @@
-import getIntl from './index';
-
-describe('intl component tests', () => {
-  const originalIntl = globalThis.Intl;
-
-  afterEach(() => {
-    Object.defineProperty(globalThis, 'Intl', {
-      value: originalIntl,
-      configurable: true,
-      writable: true,
-    });
-  });
-
-  test('returns valid structure with all expected keys', async () => {
-    const result = await getIntl();
-
-    expect(result).not.toBeNull();
-    expect(result).toHaveProperty('hash');
-    expect(result).toHaveProperty('details');
-    expect(typeof result!.hash).toBe('string');
-    const details = result!.details as Record<string, unknown>;
-    const coreKeys = [
-      'dateFullFormat', 'dateMediumFormat', 'timeFormat',
-      'numberFormat', 'currencyFormat', 'percentFormat',
-      'nonLatinDate', 'nonLatinNumber',
-    ];
-    for (const key of coreKeys) {
-      expect(details).toHaveProperty(key);
-      expect(typeof details[key]).toBe('string');
-    }
-  });
-
-  test('returns null when Intl is unavailable', async () => {
-    Object.defineProperty(globalThis, 'Intl', {
-      value: undefined,
-      configurable: true,
-      writable: true,
-    });
-
-    const result = await getIntl();
-    expect(result).toBeNull();
-  });
-
-  test('omits listFormat when ListFormat is unavailable', async () => {
-    const mockIntl = Object.create(originalIntl);
-    Object.defineProperty(mockIntl, 'ListFormat', {
-      value: undefined,
-      configurable: true,
-    });
-    Object.defineProperty(globalThis, 'Intl', {
-      value: mockIntl,
-      configurable: true,
-      writable: true,
-    });
-
-    const result = await getIntl();
-    const details = result!.details as Record<string, unknown>;
-
-    expect(result).not.toBeNull();
-    expect(details).toHaveProperty('dateFullFormat');
-    expect(details).not.toHaveProperty('listFormat');
-  });
-
-  test('omits displayNames when DisplayNames is unavailable', async () => {
-    const mockIntl = Object.create(originalIntl);
-    Object.defineProperty(mockIntl, 'DisplayNames', {
-      value: undefined,
-      configurable: true,
-    });
-    Object.defineProperty(globalThis, 'Intl', {
-      value: mockIntl,
-      configurable: true,
-      writable: true,
-    });
-
-    const result = await getIntl();
-    const details = result!.details as Record<string, unknown>;
-
-    expect(result).not.toBeNull();
-    expect(details).toHaveProperty('dateFullFormat');
-    expect(details).not.toHaveProperty('displayNames');
-  });
-
-  test('includes guarded probes when available', async () => {
-    const result = await getIntl();
-    const details = result!.details as Record<string, unknown>;
-
-    expect(result).not.toBeNull();
-    if (typeof (Intl as any).ListFormat === 'function') {
-      expect(details).toHaveProperty('listFormat');
-      expect(typeof details.listFormat).toBe('string');
-    }
-    if (typeof (Intl as any).DisplayNames === 'function') {
-      expect(details).toHaveProperty('displayNames');
-      expect(typeof details.displayNames).toBe('string');
-    }
-  });
-
-  test('returns null when Intl constructor throws', async () => {
-    const mockIntl = Object.create(originalIntl);
-    Object.defineProperty(mockIntl, 'DateTimeFormat', {
-      value: function() { throw new Error('broken'); },
-      configurable: true,
-    });
-    Object.defineProperty(globalThis, 'Intl', {
-      value: mockIntl,
-      configurable: true,
-      writable: true,
-    });
-
-    const result = await getIntl();
-    expect(result).toBeNull();
-  });
-
-  test('produces deterministic number format output', async () => {
-    const result = await getIntl();
-    const details = result!.details as Record<string, unknown>;
-
-    expect(result).not.toBeNull();
-    expect(details.numberFormat).toBe('123,456.789');
-    expect(details.currencyFormat).toBe('$123,456.79');
-    expect(details.percentFormat).toBe('46%');
-  });
-});

package/src/components/intl/index.ts

@@ -1,41 +0,0 @@
-import { componentInterface } from '../../factory';
-import { hash } from '../../utils/hash';
-import { stableStringify } from '../../utils/stableStringify';
-
-export default async function getIntl(): Promise<componentInterface | null> {
-  if (typeof Intl === 'undefined') {
-    return null;
-  }
-
-  try {
-    const date = new Date(Date.UTC(2024, 0, 15, 12, 30, 45));
-
-    const details: componentInterface = {
-      dateFullFormat: new Intl.DateTimeFormat('en-US', { dateStyle: 'full', timeZone: 'UTC' } as any).format(date),
-      dateMediumFormat: new Intl.DateTimeFormat('en-US', { dateStyle: 'medium', timeZone: 'UTC' } as any).format(date),
-      timeFormat: new Intl.DateTimeFormat('en-US', { timeStyle: 'long', timeZone: 'UTC' } as any).format(date),
-      numberFormat: new Intl.NumberFormat('en-US').format(123456.789),
-      currencyFormat: new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' }).format(123456.789),
-      percentFormat: new Intl.NumberFormat('en-US', { style: 'percent' }).format(0.456),
-      nonLatinDate: new Intl.DateTimeFormat('ar-EG', { timeZone: 'UTC' }).format(date),
-      nonLatinNumber: new Intl.NumberFormat('zh-Hans-CN-u-nu-hanidec').format(123456.789),
-    };
-
-    const IntlAny = Intl as any;
-
-    if (typeof IntlAny.ListFormat === 'function') {
-      details.listFormat = new IntlAny.ListFormat('en', { type: 'conjunction' }).format(['a', 'b', 'c']);
-    }
-
-    if (typeof IntlAny.DisplayNames === 'function') {
-      details.displayNames = new IntlAny.DisplayNames('en', { type: 'region' }).of('US') || '';
-    }
-
-    return {
-      details,
-      hash: hash(stableStringify(details)),
-    };
-  } catch {
-    return null;
-  }
-}

package/src/components/mediaDevices/index.test.ts

@@ -1,120 +0,0 @@
-import getMediaDevices from './index';
-
-describe('mediaDevices component tests', () => {
-  let originalMediaDevices: MediaDevices | undefined;
-
-  beforeAll(() => {
-    originalMediaDevices = navigator.mediaDevices;
-  });
-
-  afterAll(() => {
-    Object.defineProperty(navigator, 'mediaDevices', {
-      value: originalMediaDevices,
-      configurable: true,
-    });
-  });
-
-  function mockEnumerateDevices(devices: Array<{ kind: string }>) {
-    Object.defineProperty(navigator, 'mediaDevices', {
-      value: {
-        enumerateDevices: jest.fn().mockResolvedValue(devices),
-      },
-      configurable: true,
-    });
-  }
-
-  test('returns valid structure when API is available', async () => {
-    mockEnumerateDevices([
-      { kind: 'audioinput' },
-      { kind: 'audiooutput' },
-      { kind: 'videoinput' },
-    ]);
-
-    const result = await getMediaDevices();
-
-    expect(result).toEqual({
-      audioinput: 1,
-      audiooutput: 1,
-      videoinput: 1,
-    });
-  });
-
-  test('returns null when mediaDevices API is unavailable', async () => {
-    Object.defineProperty(navigator, 'mediaDevices', {
-      value: undefined,
-      configurable: true,
-    });
-
-    const result = await getMediaDevices();
-    expect(result).toBeNull();
-  });
-
-  test('returns null when enumerateDevices throws', async () => {
-    Object.defineProperty(navigator, 'mediaDevices', {
-      value: {
-        enumerateDevices: jest.fn().mockRejectedValue(new Error('NotAllowedError')),
-      },
-      configurable: true,
-    });
-
-    const result = await getMediaDevices();
-    expect(result).toBeNull();
-  });
-
-  test('handles empty device list', async () => {
-    mockEnumerateDevices([]);
-
-    const result = await getMediaDevices();
-
-    expect(result).toEqual({
-      audioinput: 0,
-      audiooutput: 0,
-      videoinput: 0,
-    });
-  });
-
-  test('counts multiple devices of same kind', async () => {
-    mockEnumerateDevices([
-      { kind: 'videoinput' },
-      { kind: 'videoinput' },
-      { kind: 'audioinput' },
-    ]);
-
-    const result = await getMediaDevices();
-
-    expect(result).toEqual({
-      audioinput: 1,
-      audiooutput: 0,
-      videoinput: 2,
-    });
-  });
-
-  test('ignores unknown device kind values', async () => {
-    mockEnumerateDevices([
-      { kind: 'audioinput' },
-      { kind: '' },
-      { kind: 'somethingelse' },
-      { kind: 'videoinput' },
-    ]);
-
-    const result = await getMediaDevices();
-
-    expect(result).toEqual({
-      audioinput: 1,
-      audiooutput: 0,
-      videoinput: 1,
-    });
-  });
-
-  test('returns null when enumerateDevices resolves with null', async () => {
-    Object.defineProperty(navigator, 'mediaDevices', {
-      value: {
-        enumerateDevices: jest.fn().mockResolvedValue(null),
-      },
-      configurable: true,
-    });
-
-    const result = await getMediaDevices();
-    expect(result).toBeNull();
-  });
-});

package/src/components/mediaDevices/index.ts

@@ -1,26 +0,0 @@
-import { componentInterface } from '../../factory';
-
-export default async function getMediaDevices(): Promise<componentInterface | null> {
-  if (typeof navigator === 'undefined' ||
-    !navigator.mediaDevices ||
-    typeof navigator.mediaDevices.enumerateDevices !== 'function') {
-    return null;
-  }
-
-  try {
-    const devices = await navigator.mediaDevices.enumerateDevices();
-
-    const counts: Record<string, number> = {};
-    for (const device of devices) {
-      counts[device.kind] = (counts[device.kind] || 0) + 1;
-    }
-
-    return {
-      audioinput: counts['audioinput'] || 0,
-      audiooutput: counts['audiooutput'] || 0,
-      videoinput: counts['videoinput'] || 0,
-    };
-  } catch {
-    return null;
-  }
-}

package/src/components/system/browser.test.ts

@@ -1,108 +0,0 @@
-import { getBrowser } from './browser';
-
-describe('getBrowser', () => {
-  const originalNavigator = global.navigator;
-
-  function mockUserAgent(ua: string) {
-    Object.defineProperty(global, 'navigator', {
-      value: { userAgent: ua },
-      configurable: true,
-    });
-  }
-
-  afterAll(() => {
-    // Restore original navigator
-    Object.defineProperty(global, 'navigator', {
-      value: originalNavigator,
-      configurable: true,
-    });
-  });
-
-  // Authoritative user agent test cases from DeviceAtlas
-  const cases = [
-    // Chrome (Windows)
-    {
-      ua: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.110 Safari/537.36',
-      expected: { name: 'Chrome', version: '120.0.6099.110' },
-    },
-    // Firefox (Windows)
-    {
-      ua: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:120.0) Gecko/20100101 Firefox/120.0',
-      expected: { name: 'Firefox', version: '120.0' },
-    },
-    // Edge (Windows)
-    {
-      ua: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.110 Safari/537.36 Edg/120.0.2210.61',
-      expected: { name: 'Edge', version: '120.0.2210.61' },
-    },
-    // Safari (macOS)
-    {
-      ua: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15',
-      expected: { name: 'Safari', version: '17.1' },
-    },
-    // Chrome (macOS)
-    {
-      ua: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.110 Safari/537.36',
-      expected: { name: 'Chrome', version: '120.0.6099.110' },
-    },
-    // Firefox (macOS)
-    {
-      ua: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:120.0) Gecko/20100101 Firefox/120.0',
-      expected: { name: 'Firefox', version: '120.0' },
-    },
-    // Chrome (Android)
-    {
-      ua: 'Mozilla/5.0 (Linux; Android 13; SM-G991B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.110 Mobile Safari/537.36',
-      expected: { name: 'Chrome', version: '120.0.6099.110' },
-    },
-    // Samsung Internet (Android)
-    {
-      ua: 'Mozilla/5.0 (Linux; Android 13; SAMSUNG SM-G991B) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/23.0 Chrome/120.0.6099.110 Mobile Safari/537.36',
-      expected: { name: 'SamsungBrowser', version: '23.0' },
-    },
-    // Firefox (Android)
-    {
-      ua: 'Mozilla/5.0 (Android 13; Mobile; rv:120.0) Gecko/120.0 Firefox/120.0',
-      expected: { name: 'Firefox', version: '120.0' },
-    },
-    // Safari (iPhone)
-    {
-      ua: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Mobile/15E148 Safari/604.1',
-      expected: { name: 'Safari', version: '17.1' },
-    },
-    // Chrome (iPhone)
-    {
-      ua: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/120.0.6099.110 Mobile/15E148 Safari/604.1',
-      expected: { name: 'Chrome', version: '120.0.6099.110' },
-    },
-    // Firefox (iPhone)
-    {
-      ua: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) FxiOS/120.0 Mobile/15E148 Safari/604.1',
-      expected: { name: 'Firefox', version: '120.0' },
-    },
-    // Opera (Windows)
-    {
-      ua: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.110 Safari/537.36 OPR/107.0.5045.36',
-      expected: { name: 'Opera', version: '107.0.5045.36' },
-    },
-    // Vivaldi (Windows)
-    {
-      ua: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.110 Safari/537.36 Vivaldi/6.4.3160.49',
-      expected: { name: 'Vivaldi', version: '6.4.3160.49' },
-    },
-    // Unknown
-    {
-      ua: 'SomeRandomUserAgent/1.0',
-      expected: { name: 'SomeRandomUserAgent', version: '1.0' },
-    },
-  ];
-
-  cases.forEach(({ ua, expected }) => {
-    it(`should detect ${expected.name} ${expected.version} from UA: ${ua}`, () => {
-      mockUserAgent(ua);
-      const result = getBrowser();
-      expect(result.name.toLowerCase()).toBe(expected.name.toLowerCase());
-      expect(result.version).toContain(expected.version.split('.')[0]); // loose match for version
-    });
-  });
-}); 

package/src/components/webgl/index.test.ts

@@ -1,223 +0,0 @@
-import getWebGL, { __resetWebGLCache, __getWebGLCache } from './index';
-
-// ---------------------------------------------------------------------------
-// Mock ImageData — jsdom does not provide a real implementation
-// ---------------------------------------------------------------------------
-class MockImageData {
-    data: Uint8ClampedArray;
-    width: number;
-    height: number;
-
-    constructor(dataOrWidth: Uint8ClampedArray | number, widthOrUndefined?: number, height?: number) {
-        if (dataOrWidth instanceof Uint8ClampedArray) {
-            this.data = dataOrWidth;
-            this.width = widthOrUndefined ?? 1;
-            this.height = height ?? 1;
-        } else {
-            const w = dataOrWidth as number;
-            const h = widthOrUndefined ?? 1;
-            this.data = new Uint8ClampedArray(w * h * 4);
-            this.width = w;
-            this.height = h;
-        }
-    }
-}
-(global as any).ImageData = MockImageData;
-
-// ---------------------------------------------------------------------------
-// WebGL mock factory — returns an object satisfying setupWebGL() and renderImage()
-// ---------------------------------------------------------------------------
-function makeGlMock(overrides: Partial<WebGLRenderingContext> = {}): WebGLRenderingContext {
-    const gl: any = {
-        VERTEX_SHADER: 35633,
-        FRAGMENT_SHADER: 35632,
-        ARRAY_BUFFER: 34962,
-        COMPILE_STATUS: 35713,
-        LINK_STATUS: 35714,
-        RGBA: 6408,
-        UNSIGNED_BYTE: 5121,
-        COLOR_BUFFER_BIT: 16384,
-        FLOAT: 5126,
-        LINES: 1,
-        drawingBufferWidth: 200,
-        drawingBufferHeight: 100,
-        createShader: jest.fn().mockReturnValue({}),
-        shaderSource: jest.fn(),
-        compileShader: jest.fn(),
-        getShaderParameter: jest.fn().mockReturnValue(true),
-        createProgram: jest.fn().mockReturnValue({}),
-        attachShader: jest.fn(),
-        linkProgram: jest.fn(),
-        getProgramParameter: jest.fn().mockReturnValue(true),
-        createBuffer: jest.fn().mockReturnValue({}),
-        bindBuffer: jest.fn(),
-        bufferData: jest.fn(),
-        useProgram: jest.fn(),
-        getAttribLocation: jest.fn().mockReturnValue(0),
-        enableVertexAttribArray: jest.fn(),
-        vertexAttribPointer: jest.fn(),
-        viewport: jest.fn(),
-        clearColor: jest.fn(),
-        clear: jest.fn(),
-        drawArrays: jest.fn(),
-        readPixels: jest.fn(),
-        ...overrides,
-    };
-    return gl as WebGLRenderingContext;
-}
-
-// ---------------------------------------------------------------------------
-// Suite setup
-// ---------------------------------------------------------------------------
-let originalGetContext: any;
-
-beforeAll(() => {
-    originalGetContext = HTMLCanvasElement.prototype.getContext;
-});
-
-afterAll(() => {
-    HTMLCanvasElement.prototype.getContext = originalGetContext;
-});
-
-beforeEach(() => {
-    __resetWebGLCache();
-});
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe('webgl component — context-loss recovery', () => {
-
-    // Happy path: cache is populated after first successful call
-    test('first getWebGL() call populates the cache', async () => {
-        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(makeGlMock()) as any;
-
-        await getWebGL();
-
-        expect(__getWebGLCache()).not.toBeNull();
-    });
-
-    // Cache reuse: two calls share the same canvas object
-    test('two consecutive getWebGL() calls reuse the same cached canvas', async () => {
-        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(makeGlMock()) as any;
-
-        await getWebGL();
-        const cacheAfterFirst = __getWebGLCache();
-        expect(cacheAfterFirst).not.toBeNull();
-
-        await getWebGL();
-        const cacheAfterSecond = __getWebGLCache();
-
-        // Same object reference — no new canvas was created
-        expect(cacheAfterSecond).toBe(cacheAfterFirst);
-        // getContext called exactly once (canvas created once)
-        expect(HTMLCanvasElement.prototype.getContext).toHaveBeenCalledTimes(1);
-    });
-
-    // Context-loss listener: dispatching webglcontextlost clears the cache
-    test('webglcontextlost event clears the cache', async () => {
-        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(makeGlMock()) as any;
-
-        await getWebGL();
-        const cacheBeforeLoss = __getWebGLCache();
-        expect(cacheBeforeLoss).not.toBeNull();
-
-        // Fire the context-lost event on the cached canvas
-        cacheBeforeLoss!.canvas.dispatchEvent(new Event('webglcontextlost', { cancelable: true }));
-
-        expect(__getWebGLCache()).toBeNull();
-    });
-
-    // Context-loss listener: event.preventDefault() is called
-    test('webglcontextlost listener calls event.preventDefault()', async () => {
-        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(makeGlMock()) as any;
-
-        await getWebGL();
-        const cache = __getWebGLCache();
-        expect(cache).not.toBeNull();
-
-        const lostEvent = new Event('webglcontextlost', { cancelable: true });
-        const preventDefaultSpy = jest.spyOn(lostEvent, 'preventDefault');
-
-        cache!.canvas.dispatchEvent(lostEvent);
-
-        expect(preventDefaultSpy).toHaveBeenCalledTimes(1);
-    });
-
-    // After context loss, next getWebGL() call creates a NEW canvas
-    test('getWebGL() after context loss rebuilds the cache via a new canvas', async () => {
-        const gl = makeGlMock();
-        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(gl) as any;
-
-        await getWebGL();
-        const firstCache = __getWebGLCache();
-        expect(firstCache).not.toBeNull();
-
-        // Simulate context loss
-        firstCache!.canvas.dispatchEvent(new Event('webglcontextlost', { cancelable: true }));
-        expect(__getWebGLCache()).toBeNull();
-
-        // Reset mock call count, re-install for rebuild
-        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(gl) as any;
-
-        await getWebGL();
-        const secondCache = __getWebGLCache();
-        expect(secondCache).not.toBeNull();
-        // A fresh cache object is created — different reference from the lost one
-        expect(secondCache).not.toBe(firstCache);
-        // getContext called once for the rebuild (new canvas)
-        expect(HTMLCanvasElement.prototype.getContext).toHaveBeenCalledTimes(1);
-    });
-
-    // once: true — the listener fires at most once per canvas
-    test('webglcontextlost listener fires only once (once:true)', async () => {
-        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(makeGlMock()) as any;
-
-        await getWebGL();
-        const firstCache = __getWebGLCache();
-        const canvas = firstCache!.canvas;
-
-        // First dispatch: clears cache
-        canvas.dispatchEvent(new Event('webglcontextlost', { cancelable: true }));
-        expect(__getWebGLCache()).toBeNull();
-
-        // Second dispatch on the same canvas — listener already removed (once:true),
-        // so _cache remains null (unchanged) and no throw occurs
-        expect(() => {
-            canvas.dispatchEvent(new Event('webglcontextlost', { cancelable: true }));
-        }).not.toThrow();
-        expect(__getWebGLCache()).toBeNull();
-    });
-
-    // renderImage catch block: render failure clears the cache
-    test('render failure (useProgram throws) clears the cache', async () => {
-        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(makeGlMock()) as any;
-
-        // First call populates cache
-        await getWebGL();
-        expect(__getWebGLCache()).not.toBeNull();
-
-        // Patch the cached gl to throw on the next render
-        const cache = __getWebGLCache()!;
-        (cache as any).gl.useProgram = jest.fn().mockImplementation(() => {
-            throw new Error('WebGL context lost');
-        });
-
-        // The call should not throw; it should return the 'unsupported' fallback
-        const result = await getWebGL();
-        expect(result).toEqual({ webgl: 'unsupported' });
-
-        // Cache must have been cleared by the catch block
-        expect(__getWebGLCache()).toBeNull();
-    });
-
-    // Graceful degradation: getContext returns null → returns 'unsupported'
-    test('getWebGL() returns unsupported when WebGL context is unavailable', async () => {
-        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(null) as any;
-
-        const result = await getWebGL();
-
-        expect(result).toEqual({ webgl: 'unsupported' });
-        expect(__getWebGLCache()).toBeNull();
-    });
-});