Skip to content

Open source CapCut alternative.

TypeScript
4.0 KB
Raw Blame
import { describe, expect, test } from "bun:test";
import { notePerfTrouble, perfUploadReason } from "./perfLog";
import {
  flushMeter,
  meterAudioClock,
  meterAudioLate,
  meterClockJump,
  meterFrame,
  meterPerf,
  meterPull,
  meterSource,
  meterState,
  meterWalk,
  metering,
  stopMeter,
  type PerfSample,
} from "./perfTrace";

describe("preview diagnostics meter", () => {
  test("a smooth play in a session with no reason to send sends nothing", () => {
    const out: PerfSample[] = [];
    meterPerf((s) => out.push(s));
    for (let i = 0; i < 300; i++) meterFrame(i < 30 ? 0.3 : 0, false);
    flushMeter();
    expect(out).toHaveLength(0);
    expect(perfUploadReason()).toBeNull();
    stopMeter();
  });

  test("sound starting late is trouble, and the summary says so", () => {
    const out: PerfSample[] = [];
    meterPerf((s) => out.push(s));
    for (let i = 0; i < 300; i++) meterFrame(0, false);
    meterAudioLate(0.4);
    meterAudioLate(1.2);
    meterAudioLate(0.3);
    meterClockJump();
    flushMeter();
    expect(out).toHaveLength(1);
    expect(out[0].reason).toBe("trouble");
    expect(out[0].audioLate).toBe(3);
    expect(out[0].audioLateMaxS).toBe(1.2);
    expect(out[0].clockJumps).toBe(1);
    stopMeter();
  });

  test("a play's frames become one summary", () => {
    notePerfTrouble();
    const out: PerfSample[] = [];
    meterPerf((s) => out.push(s));
    expect(metering()).toBe(true);
    // Three hundred frames: thirty of them a third of a second behind, ten of
    // those with no decoded picture at all.
    for (let i = 0; i < 300; i++) meterFrame(i < 30 ? 0.3 : 0, i < 10);
    meterState({
      sources: 12,
      held: 40,
      warmMb: 354,
      clips: 20,
      decodeHeight: 540,
      canvasHeight: 900,
    });
    meterAudioClock(0.16, 0.16);
    // Two walks anchored, the worse of them 900ms to its first frame, and a
    // pull that waited four seconds — the shape of a reader short of bytes.
    meterWalk();
    meterWalk();
    meterWalk(900);
    meterPull(20);
    meterPull(4000);
    meterSource(1920, 1080, 60, "av01");
    flushMeter();

    expect(out).toHaveLength(1);
    const s = out[0];
    expect(s.reason).toBe("trouble");
    expect(s.frames).toBe(300);
    expect(s.lateShare).toBe(0.1);
    expect(s.staleShare).toBe(0.033);
    expect(s.hitchShare).toBe(0.1);
    expect(s.lagMaxS).toBe(0.3);
    expect(s.audioLeadS).toBe(0.16);
    expect(s.audioLatencyS).toBe(0.16);
    expect(s.sources).toBe(12);
    expect(s.warmMb).toBe(354);
    expect(s.clips).toBe(20);
    expect(s.decodeHeight).toBe(540);
    expect(s.walks).toBe(2);
    expect(s.walkMs).toBe(900);
    expect(s.pullMaxMs).toBe(4000);
    expect(s.pullMeanMs).toBe(2010);
    expect(s.srcW).toBe(1920);
    expect(s.srcH).toBe(1080);
    expect(s.srcFps).toBe(60);
    expect(s.srcCodec).toBe("av01");
    stopMeter();
    expect(metering()).toBe(false);
  });

  test("a few frames are noise, and are not sent", () => {
    const out: PerfSample[] = [];
    meterPerf((s) => out.push(s));
    for (let i = 0; i < 20; i++) meterFrame(0.5, false);
    flushMeter();
    expect(out).toHaveLength(0);
    stopMeter();
  });

  test("a hitching play is trouble, and sends from then on", () => {
    const out: PerfSample[] = [];
    meterPerf((s) => out.push(s));
    // A quarter of the frames a hitch behind.
    for (let i = 0; i < 300; i++) meterFrame(i < 75 ? 0.3 : 0, false);
    flushMeter();
    expect(out).toHaveLength(1);
    expect(out[0].reason).toBe("trouble");
    expect(out[0].hitchShare).toBe(0.25);
    // The next window is smooth and still sends: the session has its reason.
    for (let i = 0; i < 300; i++) meterFrame(0, false);
    flushMeter();
    expect(out).toHaveLength(2);
    expect(perfUploadReason()).toBe("trouble");
    stopMeter();
  });

  test("counting costs nothing until it is armed", () => {
    expect(metering()).toBe(false);
    meterFrame(1, true);
    meterAudioClock(1, 1);
    flushMeter();
    expect(metering()).toBe(false);
  });
});