SnapOtter/tests/unit/image-engine/qoi.test.ts

import { readFileSync } from "node:fs";
import path from "node:path";
import { qoiDecode, qoiEncode } from "@snapotter/image-engine";
import { describe, expect, it } from "vitest";

const FORMATS_DIR = path.resolve(__dirname, "../../fixtures/formats");

describe("QOI codec", () => {
  it("round-trips RGBA pixel data", () => {
    const w = 4, h = 4;
    const pixels = new Uint8Array(w * h * 4);
    for (let i = 0; i < w * h; i++) {
      pixels[i * 4] = (i * 17) & 0xff;
      pixels[i * 4 + 1] = (i * 31) & 0xff;
      pixels[i * 4 + 2] = (i * 53) & 0xff;
      pixels[i * 4 + 3] = 255;
    }
    const encoded = qoiEncode(pixels, w, h, 4);
    const { header, pixels: decoded } = qoiDecode(encoded);
    expect(header.width).toBe(w);
    expect(header.height).toBe(h);
    for (let i = 0; i < w * h * 4; i++) expect(decoded[i]).toBe(pixels[i]);
  });

  it("encodes 3-channel data", () => {
    const w = 3, h = 3;
    const pixels = new Uint8Array(w * h * 3);
    for (let i = 0; i < pixels.length; i++) pixels[i] = (i * 41) & 0xff;
    const encoded = qoiEncode(pixels, w, h, 3);
    const { header, pixels: decoded } = qoiDecode(encoded);
    expect(header.channels).toBe(3);
    for (let i = 0; i < w * h; i++) {
      expect(decoded[i * 4 + 3]).toBe(255);
    }
  });

  it("writes correct header magic", () => {
    const encoded = qoiEncode(new Uint8Array(4), 1, 1, 4);
    const view = new DataView(encoded.buffer, encoded.byteOffset);
    expect(view.getUint32(0)).toBe(0x716f6966);
  });

  it("writes correct header dimensions", () => {
    const encoded = qoiEncode(new Uint8Array(20 * 15 * 4), 20, 15, 4);
    const view = new DataView(encoded.buffer, encoded.byteOffset);
    expect(view.getUint32(4)).toBe(20);
    expect(view.getUint32(8)).toBe(15);
    expect(encoded[12]).toBe(4);
  });

  it("round-trips 1x1 image", () => {
    const pixels = new Uint8Array([42, 128, 200, 255]);
    const { pixels: decoded } = qoiDecode(qoiEncode(pixels, 1, 1, 4));
    expect(decoded[0]).toBe(42);
    expect(decoded[3]).toBe(255);
  });

  it("round-trips solid color image", () => {
    const w = 8, h = 8;
    const pixels = new Uint8Array(w * h * 4);
    for (let i = 0; i < w * h; i++) { pixels[i*4]=100; pixels[i*4+1]=150; pixels[i*4+2]=200; pixels[i*4+3]=255; }
    const { pixels: decoded } = qoiDecode(qoiEncode(pixels, w, h, 4));
    for (let i = 0; i < pixels.length; i++) expect(decoded[i]).toBe(pixels[i]);
  });

  it("compresses solid color efficiently", () => {
    const w = 100, h = 100;
    const pixels = new Uint8Array(w * h * 4);
    for (let i = 0; i < w * h; i++) { pixels[i*4]=50; pixels[i*4+1]=100; pixels[i*4+2]=150; pixels[i*4+3]=255; }
    const encoded = qoiEncode(pixels, w, h, 4);
    expect(encoded.length).toBeLessThan(pixels.length / 10);
  });

  it("round-trips gradient", () => {
    const w = 16, h = 1;
    const pixels = new Uint8Array(w * 4);
    for (let i = 0; i < w; i++) { const v = Math.round((i/(w-1))*255); pixels[i*4]=v; pixels[i*4+1]=v; pixels[i*4+2]=v; pixels[i*4+3]=255; }
    const { pixels: decoded } = qoiDecode(qoiEncode(pixels, w, h, 4));
    for (let i = 0; i < pixels.length; i++) expect(decoded[i]).toBe(pixels[i]);
  });

  it("round-trips random-ish data", () => {
    const w = 10, h = 10;
    const pixels = new Uint8Array(w * h * 4);
    for (let i = 0; i < pixels.length; i++) pixels[i] = (i * 97 + 53) & 0xff;
    const { pixels: decoded } = qoiDecode(qoiEncode(pixels, w, h, 4));
    for (let i = 0; i < pixels.length; i++) expect(decoded[i]).toBe(pixels[i]);
  });

  it("round-trips varying alpha", () => {
    const pixels = new Uint8Array([100,150,200,0, 100,150,200,128, 100,150,200,255, 0,0,0,0]);
    const { pixels: decoded } = qoiDecode(qoiEncode(pixels, 4, 1, 4));
    for (let i = 0; i < pixels.length; i++) expect(decoded[i]).toBe(pixels[i]);
  });

  it("throws on invalid magic", () => {
    expect(() => qoiDecode(new Uint8Array(20))).toThrow();
  });

  it("throws on zero width", () => {
    const buf = new Uint8Array(14); const v = new DataView(buf.buffer);
    v.setUint32(0, 0x716f6966); v.setUint32(4, 0); v.setUint32(8, 1); buf[12] = 4;
    expect(() => qoiDecode(buf)).toThrow();
  });

  it("throws on zero height", () => {
    const buf = new Uint8Array(14); const v = new DataView(buf.buffer);
    v.setUint32(0, 0x716f6966); v.setUint32(4, 1); v.setUint32(8, 0); buf[12] = 4;
    expect(() => qoiDecode(buf)).toThrow();
  });

  it("throws on invalid channels", () => {
    const buf = new Uint8Array(14); const v = new DataView(buf.buffer);
    v.setUint32(0, 0x716f6966); v.setUint32(4, 1); v.setUint32(8, 1); buf[12] = 5;
    expect(() => qoiDecode(buf)).toThrow();
  });

  it("ends with correct end marker", () => {
    const encoded = qoiEncode(new Uint8Array([1, 2, 3, 255]), 1, 1, 4);
    expect(Array.from(encoded.slice(-8))).toEqual([0, 0, 0, 0, 0, 0, 0, 1]);
  });

  it("decodes real fixture with correct header", () => {
    const data = readFileSync(path.join(FORMATS_DIR, "sample.qoi"));
    const { header } = qoiDecode(new Uint8Array(data));
    expect(header.width).toBe(10);
    expect(header.height).toBe(10);
    expect(header.channels).toBe(4);
  });

  it("re-encodes real fixture with matching pixels", () => {
    const data = readFileSync(path.join(FORMATS_DIR, "sample.qoi"));
    const { header, pixels } = qoiDecode(new Uint8Array(data));
    const reEncoded = qoiEncode(pixels, header.width, header.height, 4);
    const { pixels: reDecoded } = qoiDecode(reEncoded);
    for (let i = 0; i < pixels.length; i++) expect(reDecoded[i]).toBe(pixels[i]);
  });
});