@xincli/opentui-core 0.4.6

package/src/tests/native-span-feed-async.test.ts

@@ -0,0 +1,173 @@
+import { test, expect } from "bun:test"
+import { NativeSpanFeed } from "../NativeSpanFeed.js"
+import { resolveRenderLib } from "../zig.js"
+
+const lib = resolveRenderLib()
+
+function writeAndCommit(stream: NativeSpanFeed, data: Uint8Array): void {
+  lib.streamWrite(stream.streamPtr, data)
+  lib.streamCommit(stream.streamPtr)
+}
+
+test("async handler keeps chunk pinned until Promise resolves", async () => {
+  // Single chunk forces reuse; async handlers must keep data pinned.
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+
+  let resolveHandler!: () => void
+  const handlerDone = new Promise<void>((r) => {
+    resolveHandler = r
+  })
+
+  let capturedData: Uint8Array | null = null
+  let dataValidAtResolve = false
+
+  stream.onData(async (data) => {
+    capturedData = data
+    const originalBytes = new Uint8Array(data)
+    await handlerDone
+    dataValidAtResolve = capturedData.every((b, i) => b === originalBytes[i])
+  })
+  const original = new Uint8Array(64)
+  for (let i = 0; i < 64; i++) original[i] = i
+  writeAndCommit(stream, original)
+  const overwrite = new Uint8Array(64).fill(0xff)
+  writeAndCommit(stream, overwrite)
+  stream.drainAll()
+  resolveHandler()
+  await new Promise((r) => setTimeout(r, 10))
+
+  expect(capturedData).not.toBeNull()
+  expect(dataValidAtResolve).toBe(true)
+
+  stream.close()
+})
+
+test("mixed sync and async handlers on same stream", async () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const syncReceived: string[] = []
+  let asyncReceived: string[] = []
+  let resolveAsync!: () => void
+  const asyncDone = new Promise<void>((r) => {
+    resolveAsync = r
+  })
+
+  stream.onData((data) => {
+    syncReceived.push(new TextDecoder().decode(data))
+  })
+  stream.onData(async (data) => {
+    const text = new TextDecoder().decode(data)
+    await asyncDone
+    asyncReceived.push(text)
+  })
+
+  const msg = new TextEncoder().encode("hello")
+  writeAndCommit(stream, msg)
+  stream.drainAll()
+
+  expect(syncReceived).toEqual(["hello"])
+  expect(asyncReceived).toEqual([])
+  resolveAsync()
+  await new Promise((r) => setTimeout(r, 10))
+
+  expect(asyncReceived).toEqual(["hello"])
+
+  stream.close()
+})
+
+test("async handler rejection still decrements refcount", async () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+
+  stream.onData(async () => {
+    throw new Error("async failure")
+  })
+
+  const data = new Uint8Array(64).fill(0xaa)
+  writeAndCommit(stream, data)
+  stream.drainAll()
+
+  await new Promise((r) => setTimeout(r, 10))
+  const received: Uint8Array[] = []
+  stream.onData((d) => {
+    received.push(new Uint8Array(d))
+  })
+
+  const data2 = new Uint8Array(64).fill(0xbb)
+  writeAndCommit(stream, data2)
+  stream.drainAll()
+
+  expect(received.length).toBe(1)
+  expect(received[0][0]).toBe(0xbb)
+
+  stream.close()
+})
+
+test("sync-only handlers decrement refcount immediately (no regression)", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+
+  const received: string[] = []
+  stream.onData((data) => {
+    received.push(new TextDecoder().decode(data))
+  })
+
+  const msg1 = new TextEncoder().encode("A".repeat(64))
+  writeAndCommit(stream, msg1)
+  stream.drainAll()
+  const msg2 = new TextEncoder().encode("B".repeat(64))
+  writeAndCommit(stream, msg2)
+  stream.drainAll()
+
+  expect(received.length).toBe(2)
+  expect(received[1]).toBe("B".repeat(64))
+
+  stream.close()
+})
+
+test("multiple async handlers all settle before refcount decrement", async () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+
+  let resolve1!: () => void
+  let resolve2!: () => void
+  const done1 = new Promise<void>((r) => {
+    resolve1 = r
+  })
+  const done2 = new Promise<void>((r) => {
+    resolve2 = r
+  })
+
+  const order: string[] = []
+
+  stream.onData(async (_data) => {
+    await done1
+    order.push("handler1")
+  })
+
+  stream.onData(async (_data) => {
+    await done2
+    order.push("handler2")
+  })
+
+  const data = new Uint8Array(64).fill(0xcc)
+  writeAndCommit(stream, data)
+  stream.drainAll()
+
+  resolve1()
+  await new Promise((r) => setTimeout(r, 10))
+  resolve2()
+  await new Promise((r) => setTimeout(r, 10))
+
+  expect(order).toEqual(["handler1", "handler2"])
+
+  const received: number[] = []
+  stream.onData((d) => {
+    received.push(d[0])
+  })
+
+  const data2 = new Uint8Array(64).fill(0xdd)
+  writeAndCommit(stream, data2)
+  stream.drainAll()
+
+  expect(received).toContain(0xdd)
+
+  stream.close()
+})

package/src/tests/native-span-feed-close.test.ts

@@ -0,0 +1,120 @@
+import { test, expect } from "bun:test"
+import { NativeSpanFeed } from "../NativeSpanFeed.js"
+import { resolveRenderLib } from "../zig.js"
+
+const lib = resolveRenderLib()
+
+function nextTick(): Promise<void> {
+  // Use a timer turn instead of process.nextTick so Promise/microtask work
+  // from async handlers and close deferral can settle before assertions.
+  return new Promise((resolve) => setTimeout(resolve, 0))
+}
+
+const enum EventId {
+  Closed = 5,
+}
+
+test("streamClose emits Closed once", () => {
+  const events: number[] = []
+
+  const streamPtr = lib.createNativeSpanFeed(null)
+  expect(streamPtr).not.toBe(0)
+  expect(streamPtr).not.toBeNull()
+  lib.registerNativeSpanFeedStream(streamPtr!, (eventId) => {
+    events.push(Number(eventId))
+  })
+  expect(lib.attachNativeSpanFeed(streamPtr!)).toBe(0)
+
+  expect(lib.streamClose(streamPtr!)).toBe(0)
+  expect(lib.streamClose(streamPtr!)).toBe(0)
+  lib.unregisterNativeSpanFeedStream(streamPtr!)
+  lib.destroyNativeSpanFeed(streamPtr!)
+
+  const closedEvents = events.filter((id) => id === EventId.Closed).length
+  expect(closedEvents).toBe(1)
+})
+
+test("destroyNativeSpanFeed emits Closed when needed", () => {
+  const events: number[] = []
+
+  const streamPtr = lib.createNativeSpanFeed(null)
+  expect(streamPtr).not.toBe(0)
+  expect(streamPtr).not.toBeNull()
+  lib.registerNativeSpanFeedStream(streamPtr!, (eventId) => {
+    events.push(Number(eventId))
+  })
+  expect(lib.attachNativeSpanFeed(streamPtr!)).toBe(0)
+  lib.destroyNativeSpanFeed(streamPtr!)
+
+  const closedEvents = events.filter((id) => id === EventId.Closed).length
+  expect(closedEvents).toBe(1)
+})
+
+test("close should not destroy immediately while async handler is still pending", async () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+  const ptr = stream.streamPtr
+
+  let release!: () => void
+  const gate = new Promise<void>((resolve) => {
+    release = resolve
+  })
+
+  let handlerStarted = false
+  let handlerSettled = false
+
+  stream.onData(async (_data) => {
+    handlerStarted = true
+    await gate
+    handlerSettled = true
+  })
+
+  const payload = new Uint8Array(64).fill(0xaa)
+  lib.streamWrite(ptr, payload)
+  lib.streamCommit(ptr)
+  stream.drainAll()
+
+  expect(handlerStarted).toBe(true)
+
+  stream.close()
+
+  const destroyedImmediately = (stream as any).destroyed === true
+
+  release()
+  await nextTick()
+
+  expect(handlerSettled).toBe(true)
+
+  try {
+    expect(destroyedImmediately).toBe(false)
+  } finally {
+    if (!(stream as any).destroyed) {
+      lib.destroyNativeSpanFeed(ptr)
+    }
+  }
+})
+
+test("close should not destroy when native close reports Busy", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1, autoCommitOnFull: false })
+  const ptr = stream.streamPtr
+
+  const reserve = lib.streamReserve(ptr, 1)
+  expect(reserve.status).toBe(0)
+
+  try {
+    stream.close()
+  } catch {
+    // If close starts throwing on Busy, that's acceptable for this assertion.
+  }
+
+  const destroyedAfterBusyClose = (stream as any).destroyed === true
+
+  try {
+    expect(destroyedAfterBusyClose).toBe(false)
+  } finally {
+    if (!(stream as any).destroyed) {
+      lib.streamCommitReserved(ptr, 0)
+      lib.streamClose(ptr)
+      lib.destroyNativeSpanFeed(ptr)
+    }
+  }
+})

package/src/tests/native-span-feed-coverage.test.ts

@@ -0,0 +1,227 @@
+import { test, expect } from "bun:test"
+import { NativeSpanFeed } from "../NativeSpanFeed.js"
+import { resolveRenderLib } from "../zig.js"
+
+const lib = resolveRenderLib()
+
+function writeData(stream: NativeSpanFeed, text: string): void {
+  const data = new TextEncoder().encode(text)
+  lib.streamWrite(stream.streamPtr, data)
+}
+
+function commitData(stream: NativeSpanFeed): void {
+  lib.streamCommit(stream.streamPtr)
+}
+
+function produceData(stream: NativeSpanFeed, text: string): void {
+  writeData(stream, text)
+  commitData(stream)
+}
+
+test("attach replays ChunkAdded and receives subsequent data", () => {
+  // Pre-queued spans should not drain until an onData handler exists.
+  // Create+close a dummy stream so ensureCallback() runs.
+  const dummy = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+  dummy.close()
+
+  const rawPtr = lib.createNativeSpanFeed({
+    chunkSize: 256,
+    initialChunks: 1,
+    autoCommitOnFull: true,
+  })
+  expect(rawPtr).not.toBe(0)
+  expect(rawPtr).not.toBeNull()
+
+  const msg1 = new TextEncoder().encode("pre-queued-1")
+  lib.streamWrite(rawPtr!, msg1)
+  lib.streamCommit(rawPtr!)
+  const stream = NativeSpanFeed.attach(rawPtr!)
+
+  const received: string[] = []
+  stream.onData((data) => {
+    received.push(new TextDecoder().decode(data))
+  })
+
+  stream.drainAll()
+  expect(received).toEqual(["pre-queued-1"])
+  const post1 = new TextEncoder().encode("post-attach-1")
+  lib.streamWrite(rawPtr!, post1)
+  lib.streamCommit(rawPtr!)
+  stream.drainAll()
+
+  expect(received).toEqual(["pre-queued-1", "post-attach-1"])
+
+  const post2 = new TextEncoder().encode("post-attach-2")
+  lib.streamWrite(rawPtr!, post2)
+  lib.streamCommit(rawPtr!)
+  stream.drainAll()
+
+  expect(received).toEqual(["pre-queued-1", "post-attach-1", "post-attach-2"])
+
+  stream.close()
+})
+
+test("multiple concurrent streams operate independently", () => {
+  const streamA = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+  const streamB = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const receivedA: string[] = []
+  const receivedB: string[] = []
+
+  streamA.onData((data) => {
+    receivedA.push(new TextDecoder().decode(data))
+  })
+  streamB.onData((data) => {
+    receivedB.push(new TextDecoder().decode(data))
+  })
+
+  produceData(streamA, "alpha")
+  streamA.drainAll()
+  produceData(streamB, "beta")
+  streamB.drainAll()
+  produceData(streamA, "gamma")
+  produceData(streamB, "delta")
+  streamA.drainAll()
+  streamB.drainAll()
+
+  expect(receivedA).toEqual(["alpha", "gamma"])
+  expect(receivedB).toEqual(["beta", "delta"])
+  streamA.close()
+
+  produceData(streamB, "epsilon")
+  streamB.drainAll()
+
+  expect(receivedB).toEqual(["beta", "delta", "epsilon"])
+  expect(receivedA).toEqual(["alpha", "gamma"])
+
+  streamB.close()
+})
+
+test("onError handler fires when Error event is received", () => {
+  // Zig doesn't emit Error yet; this verifies the handler plumbing.
+
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const errors1: number[] = []
+  const errors2: number[] = []
+
+  const unsub1 = stream.onError((code) => {
+    errors1.push(code)
+  })
+  const unsub2 = stream.onError((code) => {
+    errors2.push(code)
+  })
+
+  expect(typeof unsub1).toBe("function")
+  expect(typeof unsub2).toBe("function")
+  unsub1()
+  const received: string[] = []
+  stream.onData((data) => {
+    received.push(new TextDecoder().decode(data))
+  })
+
+  produceData(stream, "hello")
+  stream.drainAll()
+  expect(received).toContain("hello")
+
+  unsub2()
+  stream.close()
+})
+
+test("handler calling close() during drain does not crash", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const received: string[] = []
+  let closeCalled = false
+
+  stream.onData((data) => {
+    received.push(new TextDecoder().decode(data))
+    if (!closeCalled) {
+      closeCalled = true
+      stream.close()
+    }
+  })
+
+  stream.onData((data) => {
+    received.push("B:" + new TextDecoder().decode(data))
+  })
+
+  produceData(stream, "trigger")
+  expect(received).toContain("trigger")
+  stream.drainAll()
+})
+
+test("handler calling close() during drain silently drops remaining spans", () => {
+  // After close, dropping remaining spans is safe because the stream is destroyed.
+
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const received: string[] = []
+  let closeCalled = false
+
+  stream.onData((data) => {
+    received.push(new TextDecoder().decode(data))
+    if (!closeCalled && received.length >= 2) {
+      closeCalled = true
+      stream.close()
+    }
+  })
+
+  for (let i = 0; i < 5; i++) {
+    const msg = new TextEncoder().encode(`msg${i}`)
+    lib.streamWrite(stream.streamPtr, msg)
+    lib.streamCommit(stream.streamPtr)
+  }
+
+  stream.drainAll()
+  expect(received).toEqual(["msg0", "msg1"])
+  stream.drainAll()
+  expect(received).toEqual(["msg0", "msg1"])
+})
+test("draining more than 256 spans works correctly", () => {
+  // drainBuffer holds 256 spans, so drainAll must loop.
+  const stream = NativeSpanFeed.create({ chunkSize: 4096, initialChunks: 1 })
+
+  const received: Uint8Array[] = []
+  stream.onData((data) => {
+    received.push(new Uint8Array(data))
+  })
+
+  const totalSpans = 400
+
+  for (let i = 0; i < totalSpans; i++) {
+    const byte = new Uint8Array([i & 0xff])
+    lib.streamWrite(stream.streamPtr, byte)
+    lib.streamCommit(stream.streamPtr)
+  }
+
+  stream.drainAll()
+  expect(received.length).toBe(totalSpans)
+  for (let i = 0; i < totalSpans; i++) {
+    expect(received[i].length).toBe(1)
+    expect(received[i][0]).toBe(i & 0xff)
+  }
+
+  stream.close()
+})
+
+test("draining exactly 256 spans works correctly", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 4096, initialChunks: 1 })
+
+  let totalBytes = 0
+  stream.onData((data) => {
+    totalBytes += data.byteLength
+  })
+
+  for (let i = 0; i < 256; i++) {
+    const byte = new Uint8Array([0xaa])
+    lib.streamWrite(stream.streamPtr, byte)
+    lib.streamCommit(stream.streamPtr)
+  }
+
+  stream.drainAll()
+
+  expect(totalBytes).toBe(256)
+
+  stream.close()
+})