@flighthq/render-wgpu 0.3.0-next.906.07cea63 → 0.3.1-next.1041.35b950c

package/src/wgpuRenderTexture.test.ts

@@ -0,0 +1,165 @@
+import type { RenderTexture } from '@flighthq/types/contract';
+import { RenderTargetTextureSourceKind } from '@flighthq/types/contract';
+
+import { renderWgpuBackground, submitWgpuRenderPass } from './wgpuBackground';
+import { getWgpuRenderStateRuntime } from './wgpuRenderState';
+import {
+  bindWgpuRenderTexture,
+  destroyWgpuRenderTexture,
+  explainWgpuRenderTexture,
+  getWgpuRenderTextureTarget,
+  invalidateWgpuRenderTexture,
+  isWgpuRenderTextureReady,
+  renderIntoWgpuRenderTexture,
+  setWgpuRenderTextureGuard,
+  writeWgpuRenderTextureTarget,
+} from './wgpuRenderTexture';
+import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+function texture(): RenderTexture {
+  return {
+    colorSpace: 'linear',
+    flipX: false,
+    flipY: false,
+    sampler: {
+      anisotropy: 1,
+      magFilter: 'linear',
+      minFilter: 'linear',
+      mipmaps: false,
+      wrapU: 'clamp-to-edge',
+      wrapV: 'clamp-to-edge',
+    },
+    dimension: '2d',
+    source: { height: 8, kind: RenderTargetTextureSourceKind, version: 0, width: 8 },
+    uvOffset: { x: 0, y: 0 },
+    uvRotation: 0,
+    uvScale: { x: 1, y: 1 },
+    version: 0,
+  } as unknown as RenderTexture;
+}
+
+describe('bindWgpuRenderTexture', () => {
+  it('returns null before render and the state-owned target after render', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const renderTexture = texture();
+    expect(bindWgpuRenderTexture(state, renderTexture)).toBeNull();
+
+    renderWgpuBackground(state);
+    renderIntoWgpuRenderTexture(state, renderTexture, () => {});
+    expect(bindWgpuRenderTexture(state, renderTexture)).not.toBeNull();
+    submitWgpuRenderPass(state);
+  });
+});
+
+describe('destroyWgpuRenderTexture', () => {
+  it('destroys and removes the hidden target', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const renderTexture = texture();
+    renderWgpuBackground(state);
+    renderIntoWgpuRenderTexture(state, renderTexture, () => {});
+    const entry = getWgpuRenderStateRuntime(state).wgpuRenderTextureCache!.get(renderTexture)!;
+    const destroy = vi.spyOn(entry.target.texture, 'destroy');
+
+    destroyWgpuRenderTexture(state, renderTexture);
+    expect(destroy).toHaveBeenCalled();
+    expect(bindWgpuRenderTexture(state, renderTexture)).toBeNull();
+    submitWgpuRenderPass(state);
+  });
+});
+
+describe('explainWgpuRenderTexture', () => {
+  it('reports source dimensions and lifecycle status before allocation', async () => {
+    const state = await createWgpuRenderStateForTest();
+    expect(explainWgpuRenderTexture(state, texture())).toEqual({ height: 8, status: 'unrendered', width: 8 });
+  });
+});
+
+describe('getWgpuRenderTextureTarget', () => {
+  it('returns the hidden target only after a completed write', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const renderTexture = texture();
+
+    expect(getWgpuRenderTextureTarget(state, renderTexture)).toBeNull();
+    writeWgpuRenderTextureTarget(state, renderTexture, () => {});
+    expect(getWgpuRenderTextureTarget(state, renderTexture)).not.toBeNull();
+  });
+});
+
+describe('invalidateWgpuRenderTexture', () => {
+  it('makes published content unavailable without destroying its target', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const renderTexture = texture();
+    writeWgpuRenderTextureTarget(state, renderTexture, () => {});
+    const target = getWgpuRenderTextureTarget(state, renderTexture)!;
+    const destroy = vi.spyOn(target.texture, 'destroy');
+
+    invalidateWgpuRenderTexture(state, renderTexture);
+
+    expect(getWgpuRenderTextureTarget(state, renderTexture)).toBeNull();
+    expect(destroy).not.toHaveBeenCalled();
+  });
+});
+
+describe('isWgpuRenderTextureReady', () => {
+  it('tracks the successful rendered-content transition', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const renderTexture = texture();
+    expect(isWgpuRenderTextureReady(state, renderTexture)).toBe(false);
+    renderWgpuBackground(state);
+    renderIntoWgpuRenderTexture(state, renderTexture, () => {});
+    expect(isWgpuRenderTextureReady(state, renderTexture)).toBe(true);
+    submitWgpuRenderPass(state);
+  });
+});
+
+describe('renderIntoWgpuRenderTexture', () => {
+  it('restores the enclosing pass and bumps version after success', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const renderTexture = texture();
+    renderWgpuBackground(state);
+    const enclosingPass = getWgpuRenderStateRuntime(state).renderPass;
+
+    renderIntoWgpuRenderTexture(state, renderTexture, () => {});
+
+    expect(renderTexture.version).toBe(1);
+    expect(renderTexture.colorSpace).toBe('linear');
+    expect(getWgpuRenderStateRuntime(state).renderPass).not.toBeNull();
+    expect(getWgpuRenderStateRuntime(state).renderPass).not.toBe(enclosingPass);
+    submitWgpuRenderPass(state);
+  });
+});
+
+describe('setWgpuRenderTextureGuard', () => {
+  it('installs and removes the lifecycle diagnostic callback', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const renderTexture = texture();
+    const guard = vi.fn();
+
+    setWgpuRenderTextureGuard(state, guard);
+    bindWgpuRenderTexture(state, renderTexture);
+    expect(guard).toHaveBeenCalledOnce();
+
+    setWgpuRenderTextureGuard(state, null);
+    bindWgpuRenderTexture(state, renderTexture);
+    expect(guard).toHaveBeenCalledOnce();
+  });
+});
+
+describe('writeWgpuRenderTextureTarget', () => {
+  it('passes the hidden target to the producer and publishes the completed write', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const renderTexture = texture();
+    const producer = vi.fn();
+
+    writeWgpuRenderTextureTarget(state, renderTexture, producer);
+
+    expect(producer).toHaveBeenCalledOnce();
+    expect(producer.mock.calls[0][0]).toBe(getWgpuRenderTextureTarget(state, renderTexture));
+    expect(renderTexture.version).toBe(1);
+    expect(isWgpuRenderTextureReady(state, renderTexture)).toBe(true);
+  });
+});

package/src/wgpuRenderTexturePool.test.ts

@@ -0,0 +1,146 @@
+import {
+  explainWgpuRenderTexture,
+  getWgpuRenderTextureTarget,
+  isWgpuRenderTextureReady,
+  writeWgpuRenderTextureTarget,
+} from './wgpuRenderTexture';
+import {
+  acquireWgpuRenderTexture,
+  createWgpuRenderTexturePool,
+  destroyWgpuRenderTexturePool,
+  releaseWgpuRenderTexture,
+  withWgpuRenderTextures,
+} from './wgpuRenderTexturePool';
+import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
+
+beforeAll(() => installWgpuMock());
+
+describe('acquireWgpuRenderTexture', () => {
+  it('reuses a released handle and reapplies dimensions before the next write', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const pool = createWgpuRenderTexturePool();
+    const first = acquireWgpuRenderTexture(state, pool, { width: 32, height: 16 });
+    writeWgpuRenderTextureTarget(state, first, () => {});
+    releaseWgpuRenderTexture(state, pool, first);
+
+    expect(explainWgpuRenderTexture(state, first).status).toBe('released');
+    expect(isWgpuRenderTextureReady(state, first)).toBe(false);
+
+    const second = acquireWgpuRenderTexture(state, pool, { width: 80, height: 48 });
+    expect(second).toBe(first);
+    expect(second.source.width).toBe(80);
+    expect(second.source.height).toBe(48);
+    expect(explainWgpuRenderTexture(state, second).status).toBe('unrendered');
+
+    writeWgpuRenderTextureTarget(state, second, () => {});
+    expect(explainWgpuRenderTexture(state, second)).toEqual({ width: 80, height: 48, status: 'ready' });
+  });
+
+  it('resets a released slab view before exposing the next logical target', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const pool = createWgpuRenderTexturePool();
+    const slabView = acquireWgpuRenderTexture(state, pool, { width: 720, height: 480 });
+    slabView.flipX = true;
+    slabView.flipY = true;
+    slabView.uvOffset.x = 140 / 720;
+    slabView.uvOffset.y = 160 / 480;
+    slabView.uvRotation = Math.PI / 2;
+    slabView.uvScale.x = 100 / 720;
+    slabView.uvScale.y = 80 / 480;
+    releaseWgpuRenderTexture(state, pool, slabView);
+
+    const logicalTarget = acquireWgpuRenderTexture(state, pool, { width: 100, height: 80 });
+
+    expect(logicalTarget).toBe(slabView);
+    expect(logicalTarget).toMatchObject({
+      flipX: false,
+      flipY: false,
+      uvOffset: { x: 0, y: 0 },
+      uvRotation: 0,
+      uvScale: { x: 1, y: 1 },
+    });
+  });
+
+  it('does not allow a pool to cross GPU devices', async () => {
+    const a = await createWgpuRenderStateForTest();
+    const b = await createWgpuRenderStateForTest();
+    const pool = createWgpuRenderTexturePool();
+    acquireWgpuRenderTexture(a, pool, { width: 8, height: 8 });
+
+    expect(() => acquireWgpuRenderTexture(b, pool, { width: 8, height: 8 })).toThrow('cannot cross GPU devices');
+  });
+});
+
+describe('createWgpuRenderTexturePool', () => {
+  it('creates an empty device-unbound pool', () => {
+    const pool = createWgpuRenderTexturePool();
+    expect(pool.device).toBeNull();
+    expect(pool.destroyed).toBe(false);
+    expect(pool.free).toEqual([]);
+    expect(pool.leased.size).toBe(0);
+  });
+});
+
+describe('destroyWgpuRenderTexturePool', () => {
+  it('destroys hidden targets for free and outstanding leases', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const pool = createWgpuRenderTexturePool();
+    const free = acquireWgpuRenderTexture(state, pool, { width: 8, height: 8 });
+    const leased = acquireWgpuRenderTexture(state, pool, { width: 16, height: 16 });
+    writeWgpuRenderTextureTarget(state, free, () => {});
+    writeWgpuRenderTextureTarget(state, leased, () => {});
+    const destroyFree = vi.spyOn(getWgpuRenderTextureTarget(state, free)!.texture, 'destroy');
+    const destroyLeased = vi.spyOn(getWgpuRenderTextureTarget(state, leased)!.texture, 'destroy');
+    releaseWgpuRenderTexture(state, pool, free);
+
+    destroyWgpuRenderTexturePool(state, pool);
+
+    expect(destroyFree).toHaveBeenCalledOnce();
+    expect(destroyLeased).toHaveBeenCalledOnce();
+    expect(pool.free).toHaveLength(0);
+    expect(pool.leased.size).toBe(0);
+  });
+
+  it('rejects acquisition after destruction', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const pool = createWgpuRenderTexturePool();
+    destroyWgpuRenderTexturePool(state, pool);
+    expect(() => acquireWgpuRenderTexture(state, pool, { width: 8, height: 8 })).toThrow('has been destroyed');
+  });
+});
+
+describe('releaseWgpuRenderTexture', () => {
+  it('rejects a double release', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const pool = createWgpuRenderTexturePool();
+    const texture = acquireWgpuRenderTexture(state, pool, { width: 8, height: 8 });
+    releaseWgpuRenderTexture(state, pool, texture);
+
+    expect(() => releaseWgpuRenderTexture(state, pool, texture)).toThrow('texture is not leased');
+  });
+});
+
+describe('withWgpuRenderTextures', () => {
+  it('releases every lease when the bracket callback throws', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const pool = createWgpuRenderTexturePool();
+
+    expect(() =>
+      withWgpuRenderTextures(
+        state,
+        pool,
+        [
+          { width: 8, height: 8 },
+          { width: 8, height: 8 },
+          { width: 8, height: 8 },
+        ],
+        () => {
+          throw new Error('capture failed');
+        },
+      ),
+    ).toThrow('capture failed');
+
+    expect(pool.leased.size).toBe(0);
+    expect(pool.free).toHaveLength(3);
+  });
+});

package/src/wgpuShaderBinding.test.ts

@@ -1,5 +1,5 @@
 import { getOrCreateRenderProxy2D } from '@flighthq/render/contract';
-import { createBitmap } from '@flighthq/scene2d/contract';
+import { createSprite } from '@flighthq/scene2d/contract';
 import type { WgpuBitmapShader } from '@flighthq/types/contract';
 
 import { getWgpuRenderStateRuntime } from './wgpuRenderState';
@@ -13,7 +13,7 @@ beforeAll(() => {
 describe('getWgpuShader', () => {
   it('returns undefined when no shader is bound', async () => {
     const state = await createWgpuRenderStateForTest();
-    const bitmap = createBitmap();
+    const bitmap = createSprite();
     const renderProxy = getOrCreateRenderProxy2D(state, bitmap);
     expect(getWgpuShader(renderProxy)).toBeUndefined();
   });
@@ -22,7 +22,7 @@ describe('getWgpuShader', () => {
 describe('resolveWgpuShader', () => {
   it('returns null when no shader feature is enabled', async () => {
     const state = await createWgpuRenderStateForTest();
-    const bitmap = createBitmap();
+    const bitmap = createSprite();
     const renderProxy = getOrCreateRenderProxy2D(state, bitmap);
     expect(resolveWgpuShader(state, renderProxy)).toBeNull();
   });
@@ -31,7 +31,7 @@ describe('resolveWgpuShader', () => {
 describe('setWgpuShader', () => {
   it('binds a shader to a display object', async () => {
     const state = await createWgpuRenderStateForTest();
-    const bitmap = createBitmap();
+    const bitmap = createSprite();
     const fakeShader: WgpuBitmapShader = { pipeline: {} as never, bind: () => {} };
 
     setWgpuShader(state, bitmap, fakeShader);
@@ -43,7 +43,7 @@ describe('setWgpuShader', () => {
   it('installs the per-node shader binding resolver', async () => {
     const state = await createWgpuRenderStateForTest();
     const runtime = getWgpuRenderStateRuntime(state);
-    const bitmap = createBitmap();
+    const bitmap = createSprite();
     const fakeShader: WgpuBitmapShader = { pipeline: {} as never, bind: () => {} };
     expect(runtime.webgpuShaderBindingResolver).toBeUndefined();
     setWgpuShader(state, bitmap, fakeShader);
@@ -52,7 +52,7 @@ describe('setWgpuShader', () => {
 
   it('removes the binding when shader is null', async () => {
     const state = await createWgpuRenderStateForTest();
-    const bitmap = createBitmap();
+    const bitmap = createSprite();
     const fakeShader: WgpuBitmapShader = { pipeline: {} as never, bind: () => {} };
     setWgpuShader(state, bitmap, fakeShader);
     setWgpuShader(state, bitmap, null);

package/src/wgpuSurface.test.ts

@@ -1,9 +1,10 @@
+import type { WgpuRenderState } from '@flighthq/types/contract';
 import { beforeAll, describe, expect, it } from 'vitest';
 
 import { getWgpuRenderStateRuntime } from './wgpuRenderState';
 import {
   acquireWgpuFrameCaptureTexture,
-  createSurfaceFromWgpuRenderState,
+  createBitmapFromWgpuRenderState,
   enableWgpuFrameCapture,
   encodeWgpuFrameCapture,
 } from './wgpuSurface';
@@ -22,13 +23,62 @@ describe('acquireWgpuFrameCaptureTexture', () => {
   });
 });
 
-describe('createSurfaceFromWgpuRenderState', () => {
+describe('createBitmapFromWgpuRenderState', () => {
   it('throws when frame capture was never enabled (no buffer to read)', async () => {
     const state = await createWgpuRenderStateForTest();
-    await expect(createSurfaceFromWgpuRenderState(state)).rejects.toThrow(/enableWgpuFrameCapture/);
+    await expect(createBitmapFromWgpuRenderState(state)).rejects.toThrow(/enableWgpuFrameCapture/);
+  });
+
+  it('reads the mapped buffer within the bound', async () => {
+    const state = await createWgpuRenderStateForTest();
+    installCaptureBuffer(state, () => Promise.resolve());
+
+    const bitmap = await createBitmapFromWgpuRenderState(state, 1_000);
+
+    expect(bitmap.width).toBe(1);
+    expect(bitmap.height).toBe(1);
+  });
+
+  it('fails by name when the buffer never maps, instead of awaiting forever', async () => {
+    // The driver failure this bounds: mapAsync neither resolves nor rejects. Before the bound, the
+    // caller sat here until something outside it gave up and reported a stall with no location.
+    const state = await createWgpuRenderStateForTest();
+    installCaptureBuffer(state, () => new Promise<void>(() => {}));
+
+    await expect(createBitmapFromWgpuRenderState(state, 25)).rejects.toThrow(/did not map within 25ms/);
+  });
+
+  it('leaves the wait unbounded when the caller passes 0', async () => {
+    const state = await createWgpuRenderStateForTest();
+    let settle = (): void => {};
+    installCaptureBuffer(state, () => new Promise<void>((resolve) => (settle = resolve)));
+
+    let done = false;
+    const pending = createBitmapFromWgpuRenderState(state, 0).then(() => (done = true));
+    await new Promise((resolve) => setTimeout(resolve, 40));
+    expect(done).toBe(false);
+
+    settle();
+    await pending;
+    expect(done).toBe(true);
   });
 });
 
+// Installs a 1×1 retained capture buffer whose map step the caller controls, so the map bound can be
+// exercised without a GPU. The mock device's buffers carry no map surface of their own.
+function installCaptureBuffer(state: WgpuRenderState, mapAsync: () => Promise<void>): void {
+  const runtime = getWgpuRenderStateRuntime(state);
+  runtime.frameCaptureBuffer = {
+    mapAsync,
+    getMappedRange: () => new ArrayBuffer(256),
+    unmap: () => {},
+    destroy: () => {},
+  } as unknown as GPUBuffer;
+  runtime.frameCaptureWidth = 1;
+  runtime.frameCaptureHeight = 1;
+  runtime.frameCaptureBytesPerRow = 256;
+}
+
 describe('enableWgpuFrameCapture', () => {
   it('sets the capture flag on the render state runtime', async () => {
     const state = await createWgpuRenderStateForTest();
@@ -46,4 +96,46 @@ describe('encodeWgpuFrameCapture', () => {
     encodeWgpuFrameCapture(state, encoder);
     expect(copied).toBe(false);
   });
+
+  it('skips the copy while a readback holds the buffer, and resumes once it lets go', async () => {
+    // The writer/reader handshake over the single retained buffer: an animating scene must not keep
+    // enqueueing copies into a buffer a readback has mapped or is waiting to map.
+    const state = await createWgpuRenderStateForTest();
+    enableWgpuFrameCapture(state);
+    acquireWgpuFrameCaptureTexture(state);
+    const runtime = getWgpuRenderStateRuntime(state);
+    let mapState: GPUBufferMapState = 'unmapped';
+    installCaptureBuffer(state, () => Promise.resolve());
+    Object.defineProperty(runtime.frameCaptureBuffer, 'mapState', { get: () => mapState });
+
+    let copies = 0;
+    const encoder = { copyTextureToBuffer: () => copies++ } as unknown as GPUCommandEncoder;
+
+    mapState = 'pending';
+    encodeWgpuFrameCapture(state, encoder);
+    mapState = 'mapped';
+    encodeWgpuFrameCapture(state, encoder);
+    expect(copies).toBe(0);
+
+    mapState = 'unmapped';
+    encodeWgpuFrameCapture(state, encoder);
+    expect(copies).toBe(1);
+  });
+
+  it('still copies when the implementation reports no map state at all', async () => {
+    // Fails safe in the direction that keeps capturing: an undefined mapState must not read as "busy"
+    // and silence every copy for the rest of the run.
+    const state = await createWgpuRenderStateForTest();
+    enableWgpuFrameCapture(state);
+    acquireWgpuFrameCaptureTexture(state);
+    installCaptureBuffer(state, () => Promise.resolve());
+    Object.defineProperty(getWgpuRenderStateRuntime(state).frameCaptureBuffer, 'mapState', {
+      get: () => undefined,
+    });
+
+    let copies = 0;
+    encodeWgpuFrameCapture(state, { copyTextureToBuffer: () => copies++ } as unknown as GPUCommandEncoder);
+
+    expect(copies).toBe(1);
+  });
 });

package/src/wgpuTestHelper.test.ts

@@ -0,0 +1,64 @@
+import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+describe('installWgpuMock', () => {
+  it('accepts aligned writeBuffer data using typed-array element units', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const buffer = state.device.createBuffer({ size: 8, usage: GPUBufferUsage.COPY_DST });
+
+    expect(() => state.device.queue.writeBuffer(buffer, 0, new Uint16Array([0, 1, 2]), 0, 2)).not.toThrow();
+  });
+
+  it('rejects writeBuffer content whose byte length is not a multiple of four', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const buffer = state.device.createBuffer({ size: 8, usage: GPUBufferUsage.COPY_DST });
+
+    expect(() => state.device.queue.writeBuffer(buffer, 0, new Uint16Array([0, 1, 2]))).toThrow(
+      expect.objectContaining({ name: 'OperationError' }),
+    );
+  });
+
+  it('rejects writeBuffer source ranges and destination offsets outside the API contract', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const buffer = state.device.createBuffer({ size: 8, usage: GPUBufferUsage.COPY_DST });
+
+    expect(() => state.device.queue.writeBuffer(buffer, 0, new Uint32Array([0]), 2)).toThrow(
+      /data range is out of bounds/,
+    );
+    expect(() => state.device.queue.writeBuffer(buffer, 2, new Uint32Array([0]))).toThrow(
+      /bufferOffset must be a non-negative multiple of 4/,
+    );
+  });
+
+  it('rejects writeBuffer destinations without enough COPY_DST storage', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const tooSmall = state.device.createBuffer({ size: 4, usage: GPUBufferUsage.COPY_DST });
+    const wrongUsage = state.device.createBuffer({ size: 8, usage: GPUBufferUsage.VERTEX });
+
+    expect(() => state.device.queue.writeBuffer(tooSmall, 0, new Uint32Array([0, 1]))).toThrow(
+      /destination range exceeds the buffer size/,
+    );
+    expect(() => state.device.queue.writeBuffer(wrongUsage, 0, new Uint32Array([0]))).toThrow(
+      /must have COPY_DST usage/,
+    );
+  });
+
+  it('rejects writeTexture data smaller than an rgba8 copy requires', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const texture = state.device.createTexture({
+      size: [2, 2, 1],
+      format: 'rgba8unorm',
+      usage: GPUTextureUsage.COPY_DST,
+    });
+
+    expect(() =>
+      state.device.queue.writeTexture({ texture }, new Uint8Array(15), { bytesPerRow: 8, rowsPerImage: 2 }, [2, 2, 1]),
+    ).toThrow(expect.objectContaining({ name: 'OperationError' }));
+    expect(() =>
+      state.device.queue.writeTexture({ texture }, new Uint8Array(16), { bytesPerRow: 8, rowsPerImage: 2 }, [2, 2, 1]),
+    ).not.toThrow();
+  });
+});