@fairyhunter13/opentui-core 0.1.113 → 0.1.114

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()
+})

package/src/tests/native-span-feed-edge-cases.test.ts

@@ -0,0 +1,352 @@
+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("throwing handler does not prevent state buffer decrements", () => {
+  // Decrement must happen even if a handler throws.
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const received: string[] = []
+  let shouldThrow = true
+
+  stream.onData((data) => {
+    received.push(new TextDecoder().decode(data))
+    if (shouldThrow) {
+      throw new Error("handler error")
+    }
+  })
+
+  try {
+    produceData(stream, "first")
+  } catch {}
+
+  try {
+    produceData(stream, "second")
+  } catch {}
+
+  expect(received).toContain("first")
+  expect(received).toContain("second")
+  shouldThrow = false
+  produceData(stream, "third")
+
+  try {
+    stream.drainAll()
+  } catch {}
+
+  expect(received).toContain("third")
+
+  stream.close()
+})
+
+test("attach with pre-queued data waits for onData", () => {
+  const bootstrap = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+  bootstrap.close()
+  const rawPtr = lib.createNativeSpanFeed({
+    chunkSize: 128,
+    initialChunks: 1,
+    autoCommitOnFull: true,
+  })
+  expect(rawPtr).toBeTruthy()
+
+  const pre = new TextEncoder().encode("pre-attach")
+  lib.streamWrite(rawPtr!, pre)
+  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-attach"])
+
+  produceData(stream, "post-attach")
+  stream.drainAll()
+  expect(received).toEqual(["pre-attach", "post-attach"])
+
+  stream.close()
+})
+
+test("decrementRefcount with out-of-bounds chunkIndex does not crash or corrupt", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+
+  const received: string[] = []
+  let closedOnSpan = -1
+
+  stream.onData((data) => {
+    const text = new TextDecoder().decode(data)
+    received.push(text)
+    if (closedOnSpan < 0) {
+      closedOnSpan = 0
+      // Force an empty state buffer to exercise the guard.
+      ;(stream as any).stateBuffer = new Uint8Array(0)
+    }
+  })
+  for (let i = 0; i < 5; i++) {
+    const msg = new TextEncoder().encode(`s${i}`)
+    lib.streamWrite(stream.streamPtr, msg)
+    lib.streamCommit(stream.streamPtr)
+  }
+
+  stream.drainAll()
+  expect(received).toEqual(["s0", "s1", "s2", "s3", "s4"])
+
+  stream.close()
+})
+
+test("toArrayBuffer aliases Zig-owned chunk memory", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const received: Uint8Array[] = []
+  stream.onData((data) => {
+    received.push(data)
+  })
+
+  produceData(stream, "hello")
+  stream.drainAll()
+
+  expect(received.length).toBe(1)
+  const view = received[0]
+
+  const original = view[0]
+  const sentinel = original ^ 0xff
+  view[0] = sentinel
+  expect(view[0]).toBe(sentinel)
+  // Restore original value so the chunk data isn't corrupted.
+  view[0] = original
+
+  stream.close()
+})
+
+test("state buffer view stays current across chunk growth", () => {
+  // StateBuffer events must keep the TS view in sync after growth.
+  const stream = NativeSpanFeed.create({
+    chunkSize: 32,
+    initialChunks: 1,
+  })
+
+  const allData: string[] = []
+  stream.onData((data) => {
+    allData.push(new TextDecoder().decode(data))
+  })
+
+  for (let i = 0; i < 20; i++) {
+    const msg = new TextEncoder().encode(`msg${i.toString().padStart(2, "0")}`)
+    lib.streamWrite(stream.streamPtr, msg)
+    lib.streamCommit(stream.streamPtr)
+  }
+
+  stream.drainAll()
+
+  const allContent = allData.join("")
+  for (let i = 0; i < 20; i++) {
+    const expected = `msg${i.toString().padStart(2, "0")}`
+    expect(allContent).toContain(expected)
+  }
+  expect(allContent.length).toBe(20 * 5)
+
+  stream.close()
+})
+
+test("state buffer view stays current when writes span multiple chunks", () => {
+  const chunkSize = 32
+  const stream = NativeSpanFeed.create({ chunkSize, initialChunks: 1 })
+
+  const allData: Uint8Array[] = []
+  stream.onData((data) => {
+    allData.push(new Uint8Array(data)) // copy to avoid aliasing
+  })
+
+  const bigWrite = new Uint8Array(256)
+  for (let i = 0; i < 256; i++) bigWrite[i] = i & 0xff
+  lib.streamWrite(stream.streamPtr, bigWrite)
+
+  lib.streamCommit(stream.streamPtr)
+  stream.drainAll()
+  const received = new Uint8Array(allData.reduce((sum, d) => sum + d.length, 0))
+  let offset = 0
+  for (const chunk of allData) {
+    received.set(chunk, offset)
+    offset += chunk.length
+  }
+
+  expect(received.length).toBe(256)
+  for (let i = 0; i < 256; i++) {
+    expect(received[i]).toBe(i & 0xff)
+  }
+
+  stream.close()
+})
+
+test("unsubscribing self during onData iteration does not affect other handlers", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const calls: string[] = []
+
+  const unsubA = stream.onData(() => {
+    calls.push("A")
+    unsubA()
+  })
+  stream.onData(() => {
+    calls.push("B")
+  })
+
+  produceData(stream, "msg1")
+  stream.drainAll()
+
+  expect(calls).toEqual(["A", "B"])
+  produceData(stream, "msg2")
+  stream.drainAll()
+
+  expect(calls).toEqual(["A", "B", "B"])
+
+  stream.close()
+})
+
+test("unsubscribing a later handler during iteration skips it", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const calls: string[] = []
+  let unsubB: (() => void) | null = null
+
+  stream.onData(() => {
+    calls.push("A")
+    if (unsubB) {
+      unsubB()
+      unsubB = null
+    }
+  })
+
+  unsubB = stream.onData(() => {
+    calls.push("B")
+  })
+
+  produceData(stream, "msg1")
+  stream.drainAll()
+
+  expect(calls).toEqual(["A"])
+  produceData(stream, "msg2")
+  stream.drainAll()
+
+  expect(calls).toEqual(["A", "A"])
+
+  stream.close()
+})
+
+test("handler adding a new handler during iteration includes it per Set semantics", () => {
+  // Set iteration visits handlers added before they're reached.
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const calls: string[] = []
+
+  let added = false
+  stream.onData(() => {
+    calls.push("A")
+    if (!added) {
+      added = true
+      stream.onData(() => {
+        calls.push("B")
+      })
+    }
+  })
+
+  produceData(stream, "msg1")
+  stream.drainAll()
+
+  expect(calls).toEqual(["A", "B"])
+  produceData(stream, "msg2")
+  stream.drainAll()
+
+  expect(calls).toEqual(["A", "B", "A", "B"])
+
+  stream.close()
+})
+
+test("throwing handler does not skip remaining handlers for the same span", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const calls: string[] = []
+
+  stream.onData(() => {
+    calls.push("A")
+    throw new Error("handler A error")
+  })
+  stream.onData((data) => {
+    calls.push("B:" + new TextDecoder().decode(data))
+  })
+
+  try {
+    produceData(stream, "msg1")
+    stream.drainAll()
+  } catch {}
+  expect(calls).toEqual(["A", "B:msg1"])
+
+  stream.close()
+})
+
+test("reentrant drainAll from handler is safely ignored", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const received: string[] = []
+  let reentrantCallCount = 0
+
+  stream.onData((data) => {
+    received.push(new TextDecoder().decode(data))
+    reentrantCallCount++
+    stream.drainAll()
+  })
+
+  produceData(stream, "msg1")
+  produceData(stream, "msg2")
+  stream.drainAll()
+
+  expect(received).toContain("msg1")
+  expect(received).toContain("msg2")
+  expect(received.length).toBe(2)
+
+  stream.close()
+})
+
+test("committing during drain does not drop pending spans", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+
+  const received: string[] = []
+  let injected = false
+
+  stream.onData((data) => {
+    received.push(new TextDecoder().decode(data))
+    if (!injected) {
+      injected = true
+      const next = new TextEncoder().encode("inner")
+      lib.streamWrite(stream.streamPtr, next)
+      lib.streamCommit(stream.streamPtr)
+    }
+  })
+
+  const first = new TextEncoder().encode("outer")
+  lib.streamWrite(stream.streamPtr, first)
+  lib.streamCommit(stream.streamPtr)
+  stream.drainAll()
+
+  expect(received).toEqual(["outer", "inner"])
+
+  stream.close()
+})

package/src/tests/native-span-feed-use-after-free.test.ts

@@ -0,0 +1,45 @@
+import { test, expect } from "bun:test"
+import { NativeSpanFeed } from "../NativeSpanFeed.js"
+import { resolveRenderLib } from "../zig.js"
+
+const lib = resolveRenderLib()
+
+test("close clears chunkMap and internal state", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const retained: Uint8Array[] = []
+  stream.onData((data) => {
+    retained.push(data)
+  })
+
+  const data = new TextEncoder().encode("hello world")
+  lib.streamWrite(stream.streamPtr, data)
+  lib.streamCommit(stream.streamPtr)
+  stream.drainAll()
+
+  expect(retained.length).toBe(1)
+  expect(new TextDecoder().decode(retained[0])).toBe("hello world")
+
+  stream.close()
+  stream.drainAll()
+  expect(retained.length).toBe(1)
+})
+
+test("onData handlers are cleared on close", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  let callCount = 0
+  stream.onData(() => {
+    callCount++
+  })
+
+  const data = new TextEncoder().encode("before close")
+  lib.streamWrite(stream.streamPtr, data)
+  lib.streamCommit(stream.streamPtr)
+  stream.drainAll()
+  expect(callCount).toBe(1)
+
+  stream.close()
+
+  expect(callCount).toBe(1)
+})