supercov 0.0.48 → 0.0.50

package/README.md

@@ -19,6 +19,10 @@ to add a test in your own project, with a recorded example to follow along.
 npx supercov -- npm test
 ```
 
+Other ways in, all the same binary at the same version: `brew install
+supercorp-ai/tap/supercov`, or for a Go project `go run
+github.com/supercorp-ai/supercov/cmd/supercov@latest`.
+
 Everything after `--` is your test command. Supercov runs it without changing your source, tests, runner configuration, or normal build output.
 
 Then ask what is still uncovered:
@@ -152,11 +156,14 @@ cargo binstall supercov && supercov -- cargo test  # crates.io
 | Rust | Available | `npx supercov -- cargo test` |
 | Python | Available | `npx supercov -- pytest` |
 | Ruby | Available | `npx supercov -- rspec` |
+| Go | Available | `npx supercov -- go test ./...` |
+| Java | Available | `npx supercov -- mvn test` |
+| Kotlin | Available | `npx supercov -- ./gradlew test` |
 | Zig | Coming soon | — |
 | PHP | Coming soon | — |
 | C | Coming soon | — |
 
-Supercov requires Node.js 22 or newer. Rust support currently uses Rust 1.95; cargo-nextest 0.9.138 and 0.9.140 are supported. Python support requires CPython 3.12 or newer and measures pytest and unittest runs. Ruby support requires Ruby 3.3 or newer (3.4 or newer for full measurement) and measures RSpec, Minitest, test-unit and Cucumber runs.
+Supercov requires Node.js 22 or newer. Rust support currently uses Rust 1.95; cargo-nextest 0.9.138 and 0.9.140 are supported. Python support requires CPython 3.12 or newer and measures pytest and unittest runs. Ruby support requires Ruby 3.3 or newer (3.4 or newer for full measurement) and measures RSpec, Minitest, test-unit and Cucumber runs. Go support requires Go 1.22 or newer and measures `go test`. Java and Kotlin support requires a JDK 17 or newer with Maven or Gradle, and measures every JUnit Platform engine -- JUnit 5, JUnit 4 through Vintage, Kotest and Spock -- as well as TestNG.
 
 ## Supported operating systems and architectures
 
@@ -168,7 +175,7 @@ The CLI is a single native binary. `npx supercov` selects the build for the mach
 | Linux | arm64, x64 | glibc 2.28 or newer (Debian 10, Ubuntu 18.10, RHEL 8 and later), or musl (Alpine); chosen automatically |
 | Windows | arm64, x64 | Windows 10 or newer |
 
-JavaScript, TypeScript, Python, Ruby and Rust suites are verified on Linux, macOS and Windows -- CPython 3.12, 3.13 and 3.14, and Ruby 3.3, 3.4 and 4.0 on every one. Containers, VMs, and remote executors run the same Linux builds. Every release publishes the same binaries to npm, PyPI (`supercov-cli`, a wheel per platform) and RubyGems (`supercov`, a gem per platform except arm64 Windows, which Ruby has no platform for), and the source to crates.io (`supercov`).
+JavaScript, TypeScript, Python, Ruby, Rust, Go, Java and Kotlin suites are verified on Linux, macOS and Windows -- CPython 3.12, 3.13 and 3.14, Ruby 3.3, 3.4 and 4.0, and Go 1.22 and 1.25 on every one, and JDK 17 and 21 on every one that has them (Temurin publishes no 17 for arm64 Windows, so that pairing is 21 alone). Containers, VMs, and remote executors run the same Linux builds. Every release publishes the same binaries to npm, PyPI (`supercov-cli`, a wheel per platform) and RubyGems (`supercov`, a gem per platform except arm64 Windows, which Ruby has no platform for), and the source to crates.io (`supercov`).
 
 ## Supported test suites
 

package/docs/getting-started.md

@@ -16,7 +16,7 @@ When it finishes, review the test change and coverage comparison in your
 conversation. Ask separately if you want a commit or pull request.
 
 No account, config file, import, custom reporter, or hosted service is required.
-Supercov supports JavaScript, TypeScript, Rust, Python, and Ruby today.
+Supercov supports JavaScript, TypeScript, Rust, Python, Ruby, Go, Java, and Kotlin today.
 
 ## What the agent does
 
@@ -108,6 +108,8 @@ if anything is missing.
 - a working test command, including its dependencies, environment variables,
   and any local services;
 - for Rust, the Rust 1.95 toolchain;
+- for Go, Go 1.22 or newer;
+- for Java and Kotlin, JDK 17 or newer, with Maven or Gradle;
 - for Python, CPython 3.12 or newer with pytest or unittest;
 - for Ruby, Ruby 3.4 or newer with RSpec, Minitest, test-unit or Cucumber (3.3 measures lines, methods and simple branches only).
 
@@ -119,6 +121,20 @@ on crates.io (`cargo install supercov`). The first invocation may download
 Supercov from the registry. Supercov itself does not upload your source or
 coverage evidence to a Supercov service.
 
+Whichever language your project is in, you should not have to install another
+one first. Go runs it the way Go runs any tool, and without touching your
+`go.mod`:
+
+```sh supercov
+go run github.com/supercorp-ai/supercov/cmd/supercov@latest -- go test ./...
+```
+
+Homebrew installs the same binary for everything else, a JVM project included:
+
+```sh
+brew install supercorp-ai/tap/supercov
+```
+
 ## Files and cleanup
 
 Completed runs live under `.supercov/runs/`. Supercov also keeps an isolated

package/docs/supported-suites.md

@@ -1,6 +1,6 @@
 # Supported languages and test suites
 
-Supercov supports JavaScript, TypeScript, Rust, Python, and Ruby today. Start with
+Supercov supports JavaScript, TypeScript, Rust, Python, Ruby, Go, Java, and Kotlin today. Start with
 the same test command the repository already uses; Supercov detects supported
 runners inside that command.
 
@@ -10,6 +10,8 @@ npx supercov -- npx playwright test
 npx supercov -- cargo test
 npx supercov -- pytest
 npx supercov -- rspec
+npx supercov -- go test ./...
+npx supercov -- mvn test
 ```
 
 ## Language support
@@ -21,6 +23,9 @@ npx supercov -- rspec
 | Rust | Available | `npx supercov -- cargo test` |
 | Python | Available | `npx supercov -- pytest` |
 | Ruby | Available | `npx supercov -- rspec` |
+| Go | Available | `npx supercov -- go test ./...` |
+| Java | Available | `npx supercov -- mvn test` |
+| Kotlin | Available | `npx supercov -- ./gradlew test` |
 | Zig | Coming soon | — |
 | PHP | Coming soon | — |
 | C | Coming soon | — |
@@ -211,6 +216,131 @@ npx supercov -- ruby -Itest test/shapes_test.rb
 npx supercov -- bin/rails test
 ```
 
+## Go
+
+| Runner | Attribution | Current requirement |
+| --- | --- | --- |
+| `go test` | Exact per test | Go 1.22 or newer |
+| A test that calls `t.Parallel()` | Aggregate: its coverage counts run-wide | — |
+| An `Example` with an `Output` comment, and a `Fuzz` target's seed corpus | Aggregate: measured, but named by no test | — |
+
+Supercov instruments an isolated copy of the module and runs your own command
+against it. Your tree is not touched, and your test sources are not rewritten
+beyond one deferred line per test that binds it to its evidence.
+
+`go test` builds one binary per package, so each test package records its own
+evidence and Supercov merges them. It also caches packages that passed, and a
+cached package does not run — so Supercov adds `-count=1` unless your command
+already says otherwise, and tells you it did.
+
+A test that calls `t.Parallel()` runs alongside others. Probes are a store into
+one array shared by the process, so nothing can say which of two concurrent
+tests reached a line. That coverage is reported against the run rather than
+assigned to a test by guesswork: the lines count as covered, and no test claims
+them. It counts only when the run passed, for the same reason a failing test's
+coverage never counts — a failed run cannot say which of it came from the test
+that failed.
+
+An `Example` with an `Output` comment and a `Fuzz` target's seed corpus are
+measured the same way. `go test` runs both, so what they reach is real
+coverage, but neither takes a `*testing.T` for a result to be named by.
+
+Supercov also writes evidence as the suite runs, not only at the end. Go offers
+no way to run code on `os.Exit`, and a `TestMain` need not reach the `m.Run()`
+call Supercov wraps — `goleak.VerifyTestMain(m)` runs the suite and exits
+itself. Without periodic writes such a run recorded nothing at all.
+
+For assertion maps, `t.Error`, `t.Errorf`, `t.Fatal`, `t.Fatalf` and testify's
+`assert` and `require` are inventoried. A Go test states its claim with an `if`
+and reports the violation, so the report is the site.
+
+A repository with several modules works either way it is laid out. A directory
+with a `go.mod` of its own that no `go.work` names is a different module, and
+`go test ./...` walks past it, so Supercov leaves it alone. A `go.work`
+workspace has no module at its root, so each module it names gets a runtime of
+its own.
+
+```sh
+npx supercov -- go test ./...
+npx supercov -- go test -run TestParser ./internal/...
+npx supercov -- go test ./core/... ./app/...
+```
+
+## Java and Kotlin
+
+| Runner | Attribution | Current requirement |
+| --- | --- | --- |
+| JUnit 5 (Jupiter) | Exact per test | JDK 17 or newer, Maven or Gradle |
+| JUnit 4 (through Vintage) | Exact per test | — |
+| Kotest | Exact per test, under the names Kotest itself reports | — |
+| Spock | Exact per feature, under the names Spock itself reports | — |
+| TestNG | Exact per test, each data-provider invocation its own | — |
+| JUnit 4 alone | Exact per test, through Vintage — see below | Maven |
+
+Multi-module builds are measured module by module: each compiles its own source
+set and forks its own JVM, so each gets a runtime and records evidence of its
+own, and the run merges them. A build that forks several JVMs to run tests in
+parallel — Gradle's `maxParallelForks`, surefire's `forkCount` — is measured
+the same way: each JVM writes evidence of its own and the run merges every
+one.
+
+Attribution comes from the framework's own lifecycle rather than from rewritten
+test sources: a JUnit Platform listener sees every engine built on the platform,
+which is what covers Kotest and Spock, whose tests are not annotated methods any
+rewriter could find. TestNG is not a platform engine and has a listener of its
+own. Tests keep the names their framework chose, so a coverage report and a test
+report name the same thing.
+
+JUnit 4 on its own is not a platform engine and does not run on one. Maven and
+Gradle choose a test provider from what is on the classpath, so putting the
+platform there makes the build pick a provider that finds no engine and fail.
+For a Maven module, Supercov adds `junit-vintage-engine` to the copy — the
+platform's own way of running exactly those JUnit 4 tests through the lifecycle
+it listens to — and measures them; your own build still runs JUnit 4 as it did.
+A Gradle module is left alone and told about rather than broken.
+
+Supercov instruments an isolated copy and leaves your build file alone. In the
+copy it adds a test-scoped `junit-platform-launcher`, because the listener is
+compiled from the project's test sources and neither Maven nor Gradle puts that
+API on the compile classpath; it disables JUnit's parallel execution, keeping
+whatever else your `junit-platform.properties` set; and it stops the copy
+failing its build on warnings, because the copy holds instrumented code your
+project never wrote a style policy for. Warnings are still reported.
+
+If tests do run concurrently anyway, Supercov says so and stops attributing
+rather than reporting numbers nobody can trust: statements and branches still
+count run-wide, and condition coverage is dropped, because concurrent
+evaluations corrupt the state it is computed from.
+
+Some conditions are read by the compiler as well as evaluated at runtime, and
+those Supercov leaves exactly as written. `x instanceof String s`, a record
+deconstruction pattern, and Kotlin's `x is String` or `x != null` all narrow a
+type for the code beneath them; wrapping such a condition to observe its
+operands would take the narrowing away and the code would stop compiling. An
+`if` is still measured — which way it went is recorded from inside its arms
+instead — but it carries no condition vectors, so it contributes no MC/DC
+obligation. A loop is a harder case: it has one arm, and no place to record an
+exit a `break` would not also reach, so a loop whose condition narrows a type
+carries no branch obligation at all rather than one no test could close. The
+same goes for a loop over a constant, `while (true)`, which can only go one
+way. A Kotlin `contract { }` has to stay the first statement of its function,
+so the probe that records the function being entered is written after it.
+
+Every one of these is named in the run: ask for `supercov runs latest
+limitations` and each appears with its file, its line, and why it was left
+alone. A source file the parser cannot read is declared there too, so a hole in
+the denominator stays visible after the build log is gone.
+
+For assertion maps, forms spelled `assertSomething`, `assertThat` or `fail` are
+inventoried, which covers JUnit, TestNG, AssertJ, Hamcrest and kotlin.test.
+Kotest's infix matchers are not.
+
+```sh
+npx supercov -- mvn test
+npx supercov -- ./gradlew test
+npx supercov -- ./mvnw verify
+```
+
 ## Containers, VMs, and remote execution
 
 Supercov can collect from supported processes launched through a container, VM,

package/docs/troubleshooting.md

@@ -75,6 +75,33 @@ Its lines, methods and simple branches stay measured; everything that needs a
 probe is declared as a measurement limit for that file. Please report the file,
 since Supercov aims to instrument every Ruby source correctly.
 
+## A test that reads your source fails under Supercov
+
+A test that opens your source files and asserts on their text sees the probes,
+because that is what instrumentation is. RxJava has one: `CheckCatchThrowIfFatal`
+reads every `catch` block in the project and requires the first statement to be
+`Exceptions.throwIfFatal`, and under Supercov the first statement is a probe. An
+architecture or convention test that scans bytecode or source can fail the same
+way.
+
+Nothing is wrong with the measurement and nothing your code does has changed --
+the run still records every test that ran -- but the command exited non-zero, so
+its coverage is reported as diagnostic and cannot gate. Leave that one test out
+of the command you give Supercov. Surefire excludes by name:
+
+```sh supercov
+npx supercov -- mvn test -Dtest='!CheckCatchThrowIfFatalTest'
+```
+
+Gradle's `--tests` only includes, so exclude it in your build file instead --
+Supercov measures the copy, and your own build is unaffected by what it runs:
+
+```groovy
+test { filter { excludeTestsMatching "*CheckCatchThrowIfFatal*" } }
+```
+
+Either way your own build still runs the test, against your own sources.
+
 ## A run is marked stale
 
 A stored run remains valid history, but it stops describing the current

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supercov",
-  "version": "0.0.48",
+  "version": "0.0.50",
   "description": "Coverage for coding agents and software factories \ud83c\udf19",
   "license": "MIT",
   "repository": {
@@ -76,7 +76,7 @@
     "benchmark:check": "cargo build --release -p supercov && node scripts/rust-transform-benchmark.mjs",
     "benchmark:python-monitoring": "cargo build -p supercov && node scripts/python-monitoring-benchmark.mjs",
     "check": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && npm run test && npm run test:runtime && npm run test:rust-assets && npm run test:assertion-maps && node scripts/package-preflight.mjs && node scripts/verify-binstall-metadata.mjs --offline",
-    "release:check": "cargo clean && node scripts/sweep-target.mjs && npm run check && npm run test:engine && npm run test:fixture && npm run test:watchdog && npm run test:engine-contract && npm run test:agent && npm run test:child-attribution && npm run test:host-loader && npm run test:python-monitoring && npm run test:ruby-coverage && npm run test:rust-public-cargo && npm run test:packed-npx && npm run test:clang-mcdc && npm run benchmark:check",
+    "release:check": "cargo clean && node scripts/sweep-target.mjs && npm run check && npm run test:engine && npm run test:go && npm run test:jvm && npm run test:fixture && npm run test:watchdog && npm run test:engine-contract && npm run test:agent && npm run test:child-attribution && npm run test:host-loader && npm run test:python-monitoring && npm run test:ruby-coverage && npm run test:rust-public-cargo && npm run test:packed-npx && npm run test:clang-mcdc && npm run benchmark:check",
     "release:bump": "node scripts/bump-version.mjs",
     "sweep": "node scripts/sweep-target.mjs",
     "oracle:rust": "cargo build --release -p supercov && node scripts/rust-coverage-oracle.mjs",
@@ -86,6 +86,8 @@
     "test:host-loader": "cargo build -p supercov && node scripts/rust-host-loader-integration.mjs",
     "test:python-monitoring": "cargo build -p supercov && node scripts/python-monitoring-integration.mjs",
     "test:ruby-coverage": "cargo build -p supercov && node scripts/ruby-coverage-integration.mjs",
+    "test:go": "cargo test --no-fail-fast -p supercov-engine --test go_frontend --test go_run",
+    "test:jvm": "cargo test --no-fail-fast -p supercov-engine --test jvm_frontend --test jvm_run -- --include-ignored --test-threads=1",
     "test:rust-public-cargo": "cargo build -p supercov && node scripts/rust-public-cargo-integration.mjs",
     "test:assertion-maps": "cargo build -p supercov && node scripts/assertion-map-schema.mjs --check && node scripts/assertion-map-integration.mjs && node scripts/assertion-map-js-integration.mjs && node scripts/assertion-dogfood-integration.mjs",
     "test:assertion-maps:js": "cargo build -p supercov && node scripts/assertion-map-schema.mjs --check && node scripts/assertion-map-js-integration.mjs && node scripts/assertion-dogfood-integration.mjs",
@@ -94,14 +96,14 @@
     "docs:check": "node scripts/sync-docs.mjs --check"
   },
   "optionalDependencies": {
-    "@supercov/cli-darwin-arm64": "0.0.48",
-    "@supercov/cli-darwin-x64": "0.0.48",
-    "@supercov/cli-linux-arm64-gnu": "0.0.48",
-    "@supercov/cli-linux-arm64-musl": "0.0.48",
-    "@supercov/cli-linux-x64-gnu": "0.0.48",
-    "@supercov/cli-linux-x64-musl": "0.0.48",
-    "@supercov/cli-win32-arm64": "0.0.48",
-    "@supercov/cli-win32-x64": "0.0.48"
+    "@supercov/cli-darwin-arm64": "0.0.50",
+    "@supercov/cli-darwin-x64": "0.0.50",
+    "@supercov/cli-linux-arm64-gnu": "0.0.50",
+    "@supercov/cli-linux-arm64-musl": "0.0.50",
+    "@supercov/cli-linux-x64-gnu": "0.0.50",
+    "@supercov/cli-linux-x64-musl": "0.0.50",
+    "@supercov/cli-win32-arm64": "0.0.50",
+    "@supercov/cli-win32-x64": "0.0.50"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",