test: TerminalView queue suite (vitest) and android pure-logic units (junit)

Author: AprilNEA

.github/workflows/ci.yml

@@ -22,6 +22,7 @@ jobs:
       - run: pnpm install --frozen-lockfile
       - run: pnpm lint
       - run: pnpm exec tsc --noEmit
+      - run: pnpm test
       - run: pnpm clean && pnpm build
 
   android:
@@ -52,6 +53,10 @@ jobs:
       - name: Prebuild example android project
         run: pnpm --dir example exec expo prebuild --platform android --no-install
 
+      - name: Run module unit tests
+        working-directory: example/android
+        run: ./gradlew :expo-libghostty:testDebugUnitTest
+
       # Release with minification exercises R8 over the module's reflection
       # (expo-modules registration, Records) and JNI surface, not just compilation.
       - name: Build example app (release, R8 minified)

.npmignore

@@ -20,3 +20,8 @@
 /eslint.config.cjs
 /pnpm-workspace.yaml
 /tsconfig.json
+
+# Tests never ship
+/vitest.config.ts
+/src/__tests__/
+/android/src/test/

CHANGELOG.md

@@ -10,6 +10,12 @@
 
 ### 💡 Others
 
+- First automated test suites: vitest covers the TerminalView imperative
+  queue (the 0.8.1 mount-race contract), and JUnit covers the Android
+  snapshot wire format, cell color resolution, and the sticky-modifier state
+  machine (extracted into `SnapshotFormat.kt` / `StickyModifier.kt`). Both
+  run in CI.
+
 ## 0.8.1 — 2026-07-17
 
 ### 🐛 Bug fixes

android/build.gradle

@@ -35,3 +35,7 @@ android {
     }
   }
 }
+
+dependencies {
+  testImplementation 'junit:junit:4.13.2'
+}

android/src/test/java/expo/modules/libghostty/SnapshotFormatTest.kt

@@ -0,0 +1,147 @@
+package expo.modules.libghostty
+
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class SnapshotFormatTest {
+  // Mirrors the writer in ghostty_jni.cpp: 13×i32, little-endian.
+  private fun headerBuffer(vararg fields: Int): ByteBuffer {
+    val buf = ByteBuffer.allocate(HEADER_BYTES + 8).order(ByteOrder.LITTLE_ENDIAN)
+    for (field in fields) buf.putInt(field)
+    buf.position(0)
+    return buf
+  }
+
+  @Test
+  fun `header size matches the declared v2 layout`() {
+    assertEquals(13 * Int.SIZE_BYTES, HEADER_BYTES)
+  }
+
+  @Test
+  fun `read decodes every header field and consumes exactly the header`() {
+    val buf = headerBuffer(
+      2, // version
+      DIRTY_FULL,
+      80, // cols
+      24, // rows
+      0xFF1E1E2E.toInt(), // background
+      0xFFCDD6F4.toInt(), // foreground
+      12, // cursorX
+      3, // cursorY
+      CURSOR_STYLE_BLOCK,
+      1, // cursorVisible
+      24, // rowCount
+      1, // cursorBlinks
+      0xFFF5C2E7.toInt(), // cursorColor
+    )
+    val header = SnapshotHeader.read(buf)
+    assertEquals(2, header.version)
+    assertEquals(DIRTY_FULL, header.dirtyKind)
+    assertEquals(80, header.cols)
+    assertEquals(24, header.rows)
+    assertEquals(0xFF1E1E2E.toInt(), header.background)
+    assertEquals(0xFFCDD6F4.toInt(), header.foreground)
+    assertEquals(12, header.cursorX)
+    assertEquals(3, header.cursorY)
+    assertEquals(CURSOR_STYLE_BLOCK, header.cursorStyle)
+    assertTrue(header.cursorVisible)
+    assertEquals(24, header.rowCount)
+    assertTrue(header.cursorBlinks)
+    assertEquals(0xFFF5C2E7.toInt(), header.cursorColor)
+    assertEquals(HEADER_BYTES, buf.position())
+  }
+
+  @Test
+  fun `zero int fields decode as false and unconfigured cursor color`() {
+    val buf = headerBuffer(2, 0, 80, 24, 0, 0, 0, 0, CURSOR_STYLE_BAR, 0, 0, 0, 0)
+    val header = SnapshotHeader.read(buf)
+    assertFalse(header.cursorVisible)
+    assertFalse(header.cursorBlinks)
+    assertEquals(0, header.cursorColor)
+  }
+}
+
+class ResolveCellColorsTest {
+  private val fg = 0xFFAA0000.toInt()
+  private val bg = 0xFF00AA00.toInt()
+  private val defaultFg = 0xFFEEEEEE.toInt()
+  private val defaultBg = 0xFF111111.toInt()
+  private val themeFg = 0xFF101010.toInt()
+  private val themeBg = 0xFFF0F0F0.toInt()
+
+  private fun resolve(
+    flags: Int = 0,
+    selected: Boolean = false,
+    selectionFg: Int? = null,
+    selectionBg: Int? = null,
+  ) = resolveCellColors(fg, bg, flags, selected, defaultFg, defaultBg, selectionFg, selectionBg)
+
+  private fun assertColors(expectedFg: Int, expectedBg: Int, packed: Long) {
+    assertEquals(expectedFg, packedFg(packed))
+    assertEquals(expectedBg, packedBg(packed))
+  }
+
+  @Test
+  fun `explicit colors pass through`() {
+    assertColors(fg, bg, resolve())
+  }
+
+  @Test
+  fun `default flags substitute the terminal defaults`() {
+    assertColors(defaultFg, bg, resolve(flags = FLAG_FG_DEFAULT))
+    assertColors(fg, defaultBg, resolve(flags = FLAG_BG_NONE))
+    assertColors(defaultFg, defaultBg, resolve(flags = FLAG_FG_DEFAULT or FLAG_BG_NONE))
+  }
+
+  @Test
+  fun `inverse swaps the resolved colors`() {
+    assertColors(bg, fg, resolve(flags = FLAG_INVERSE))
+    // Defaults resolve first, then swap.
+    assertColors(defaultBg, defaultFg, resolve(flags = FLAG_FG_DEFAULT or FLAG_BG_NONE or FLAG_INVERSE))
+  }
+
+  @Test
+  fun `selection without a theme swaps like inverse`() {
+    assertColors(bg, fg, resolve(selected = true))
+  }
+
+  @Test
+  fun `selection on an inverse cell swaps back to the original colors`() {
+    assertColors(fg, bg, resolve(flags = FLAG_INVERSE, selected = true))
+  }
+
+  @Test
+  fun `themed selection background keeps the cell foreground`() {
+    assertColors(fg, themeBg, resolve(selected = true, selectionBg = themeBg))
+  }
+
+  @Test
+  fun `themed selection foreground applies only with a themed background`() {
+    assertColors(themeFg, themeBg, resolve(selected = true, selectionFg = themeFg, selectionBg = themeBg))
+    // Foreground alone falls back to the classic swap.
+    assertColors(bg, fg, resolve(selected = true, selectionFg = themeFg))
+  }
+
+  @Test
+  fun `themed selection overrides an inverse cell`() {
+    assertColors(themeFg, themeBg, resolve(flags = FLAG_INVERSE, selected = true, selectionFg = themeFg, selectionBg = themeBg))
+  }
+
+  @Test
+  fun `unselected cells ignore the selection theme`() {
+    assertColors(fg, bg, resolve(selectionFg = themeFg, selectionBg = themeBg))
+  }
+
+  @Test
+  fun `packing round-trips negative ARGB ints`() {
+    val packed = resolveCellColors(
+      0x80000000.toInt(), 0xFFFFFFFF.toInt(), 0, false,
+      defaultFg, defaultBg, null, null
+    )
+    assertColors(0x80000000.toInt(), 0xFFFFFFFF.toInt(), packed)
+  }
+}

android/src/test/java/expo/modules/libghostty/StickyModifierTest.kt

@@ -0,0 +1,91 @@
+package expo.modules.libghostty
+
+import expo.modules.libghostty.StickyModifier.Activation
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class StickyModifierTest {
+  private var clock = 0L
+  private val modifier = StickyModifier { clock }
+
+  @Test
+  fun `tap arms an inactive modifier`() {
+    modifier.tap()
+    assertEquals(Activation.ARMED, modifier.activation)
+    assertTrue(modifier.engaged)
+    assertFalse(modifier.locked)
+  }
+
+  @Test
+  fun `consume unlatches an armed modifier`() {
+    modifier.tap()
+    modifier.consume()
+    assertEquals(Activation.INACTIVE, modifier.activation)
+    assertFalse(modifier.engaged)
+  }
+
+  @Test
+  fun `consume keeps an inactive modifier inactive`() {
+    modifier.consume()
+    assertEquals(Activation.INACTIVE, modifier.activation)
+  }
+
+  @Test
+  fun `double tap within the window locks`() {
+    modifier.tap()
+    clock += StickyModifier.DOUBLE_TAP_MS - 1
+    modifier.tap()
+    assertEquals(Activation.LOCKED, modifier.activation)
+    assertTrue(modifier.locked)
+  }
+
+  @Test
+  fun `slow second tap deactivates instead of locking`() {
+    modifier.tap()
+    clock += StickyModifier.DOUBLE_TAP_MS
+    modifier.tap()
+    assertEquals(Activation.INACTIVE, modifier.activation)
+  }
+
+  @Test
+  fun `consume does not release a locked modifier`() {
+    modifier.tap()
+    clock += 1
+    modifier.tap()
+    modifier.consume()
+    assertEquals(Activation.LOCKED, modifier.activation)
+  }
+
+  @Test
+  fun `tap releases a locked modifier`() {
+    modifier.tap()
+    clock += 1
+    modifier.tap()
+    clock += 1
+    modifier.tap()
+    assertEquals(Activation.INACTIVE, modifier.activation)
+  }
+
+  @Test
+  fun `quick re-tap after consumption arms instead of locking`() {
+    modifier.tap()
+    modifier.consume()
+    clock += 1
+    modifier.tap()
+    assertEquals(Activation.ARMED, modifier.activation)
+  }
+
+  @Test
+  fun `arming again after a lock cycle starts from armed`() {
+    modifier.tap() // armed
+    clock += 1
+    modifier.tap() // locked
+    clock += 1
+    modifier.tap() // inactive
+    clock += StickyModifier.DOUBLE_TAP_MS + 1
+    modifier.tap()
+    assertEquals(Activation.ARMED, modifier.activation)
+  }
+}

package.json

@@ -8,6 +8,7 @@
     "build": "node internal/module_scripts/build.js",
     "clean": "node internal/module_scripts/clean.js",
     "lint": "eslint src/",
+    "test": "vitest run",
     "prepare": "node internal/module_scripts/prepare.js",
     "postinstall": "node scripts/download-xcframework.mjs && node scripts/download-android-libs.mjs",
     "sync-vendor": "./scripts/sync-vendor.sh",
@@ -34,9 +35,13 @@
     "eslint": "~9.39.4",
     "eslint-config-universe": "^15.0.3",
     "expo": "^57.0.5",
+    "jsdom": "^29.1.1",
     "prettier": "^3.0.0",
+    "react": "^19.2.3",
+    "react-dom": "19.2.3",
     "react-native": "0.86.0",
-    "typescript": "^5.9.2"
+    "typescript": "^5.9.2",
+    "vitest": "^4.1.10"
   },
   "peerDependencies": {
     "expo": "*",