go-mutesting
go-mutesting is a free, MIT-licensed framework for mutation testing Go code.
What go-mutesting is
go-mutesting is a free, MIT-licensed framework for mutation testing Go code. It alters source code in generated ways, runs tests, and reports whether each change is caught. Its mutation score reflects the share of generated mutations killed by the test suite; surviving mutations are accompanied by a source patch. Targets may be Go files, directories, or packages, including recursive `...` patterns, while `_test` files are excluded. By default, it replaces the original file with a mutation and runs the package tests. Alternatively, `--exec` lets users provide an external test command; environment variables describe each mutation and exit codes report whether it was killed, remained alive, was skipped, or had an unknown outcome. Built-in mutators cover branches, comparisons, boolean expressions, statement removal, and Cosmos SDK arithmetic and comparisons. Custom mutators can be implemented through the Mutator interface and registered with the binary. A checksum blacklist can ignore false positives, but the README says it is poorly implemented because source changes alter checksums. The project presents mutation testing as a supplement to automatic test suites, not a replacement.
Good
- Reports a mutation score.
- Prints source patches for surviving mutations.
- Supports Go package tests and external commands.
- Custom mutators can be registered.
Watch out
- Targets exclude `_test` files.
- Checksum blacklist is described as poorly implemented.
- Mutation testing can produce false positives.
Who it suits
go-mutesting suits Go developers who want to check whether their tests catch changes to their code. It can also help compare automatically generated and manually written test suites, but should supplement automatic testing.
Verdict
go-mutesting provides mutation results and surviving-code patches for Go projects, with built-in and custom mutators. Its own guidance treats mutation testing as a supplement because false positives can occur.
Plans and prices
From go-mutesting's own pricing page, checked 9 Oct 2026.
| Plan | Price | What it gives you |
|---|---|---|
| go-mutesting | Free | MIT-licensed Go mutation testing framework |
The facts
Each one read from go-mutesting's own pages, with the date it was checked.
What it does
- Custom commands
- Users can provide an external execution command for testing each mutation.checked 9 Oct 2026
- Custom execution
- Users can supply an external exec command to test mutations, with environment variables describing each mutation and exit codes indicating killed, alive, skipped, or unknown outcomes.checked 4 Oct 2026
- Execution
- The built-in execution command replaces a source file with a mutation, runs the package tests, and reports whether the mutation was killed.checked 9 Oct 2026
- Extensibility
- Custom mutators implement the Mutator interface and are registered with the package's Register function.checked 9 Oct 2026
- False positives
- A checksum blacklist can ignore mutations, but the README says this feature is badly implemented because source changes alter all checksums.checked 9 Oct 2026
- Inputs
- Targets can be Go source files, directories, or packages, including recursive `...` patterns; `_test` files are excluded.checked 9 Oct 2026
- Integration
- The tool can run Go package tests by default and supports external test commands through `--exec`.checked 4 Oct 2026
- Intended use
- The README describes go-mutesting as an addition to automatic test suites and says it can help compare automatically generated and manually written test suites.checked 4 Oct 2026
- License
- The repository identifies the project as MIT licensed.checked 9 Oct 2026
- Mutation results
- It reports whether each mutation was tested and prints a source patch when a mutation survives.checked 9 Oct 2026
- Mutation score
- It reports a mutation score based on the proportion of mutations killed by the test suite.checked 9 Oct 2026
- Mutators
- Implemented mutators cover branches, comparisons, boolean expressions, statement removal, and Cosmos SDK arithmetic and comparisons.checked 9 Oct 2026
- Purpose
- go-mutesting performs mutation testing on Go source code to find code that is not covered by tests.checked 9 Oct 2026
- Support
- The README invites users to make feature requests and report bugs or problems.checked 9 Oct 2026
- Targets
- Targets can be Go source files, directories, or packages, including recursive `...` patterns; `_test` files are excluded.checked 4 Oct 2026
- Usage limitation
- The README says mutation testing can produce false positives and should supplement automatic test suites.checked 9 Oct 2026
The full review of go-mutesting
go-mutesting is a free, MIT-licensed mutation-testing framework for Go projects. It is best suited to developers who already run Go package tests and want evidence that those tests detect realistic code changes. The practical payoff is its combination of a mutation score and surviving-code patches, tempered by a documented risk of false positives.
Overview
The framework deliberately alters production Go source, executes tests, and records whether each alteration is killed. It accepts individual files, directories, or packages, including recursive ... patterns, while excluding _test files. A mutation score summarizes the proportion of generated changes rejected by the suite.
By default, go-mutesting substitutes the original file with a mutant and runs that package's tests. Surviving mutants are accompanied by source patches, turning an abstract score into specific code for review. This workflow is efficient for conventional Go package testing, but it is intentionally a developer tool rather than a broad test-management system.
Key features
Operators and diagnostics
Built-in mutators target branch cases, if and else paths, comparisons, boolean expressions, and statement removal. Projects using the Cosmos SDK additionally receive arithmetic and comparison mutations. The resulting per-mutation status shows what was tested, while a surviving patch highlights where assertions may be insufficient.
Custom test execution
The --exec option lets you replace the default package-test command with an external command. Environment variables describe each mutation, and exit codes distinguish killed, alive, skipped, and unknown outcomes. That flexibility helps teams with nonstandard test orchestration, provided they can implement the required command contract.
Extensibility and false positives
Custom mutators can implement the Mutator interface and be registered with the binary, allowing teams to encode domain-specific changes. A checksum blacklist can suppress known false positives, but the project documentation cautions that source edits change checksums and calls the feature poorly implemented. Results therefore need human review rather than blind acceptance.
Pricing
go-mutesting costs free under its single “go-mutesting” plan. It is open source under the MIT license, with no paid tier or free-trial period. There are no stated seat, usage, or quota charges, making it suitable for individual developers and teams that can operate the tooling themselves. The trade-off is that the package provides no commercial plan with additional service terms.
Platforms
The supported platform is Linux, with a self-hosted operating model. Its language and test-framework scope is Go source with Go package tests by default; external commands extend execution to other test setups. Teams standardized on macOS or Windows, or seeking a hosted service, should choose a different tool.
Who it's for
Choose go-mutesting for a Go codebase where ordinary test suites exist and maintainers want to measure whether tests catch altered branches, expressions, and statements. It also fits Cosmos SDK projects needing those domain-specific operators, and teams able to maintain custom mutators or an external test command.
It is a poor fit for projects outside Go, teams that need a graphical or hosted workflow, or anyone expecting mutation testing to replace normal automated tests. The project's own usage guidance positions mutation analysis as an addition to test suites because false positives can occur.
Pros and cons
Pros
- Concrete feedback: mutation scores are paired with surviving-code patches, giving developers a direct investigation target.
- Useful input coverage: files, directories, packages, and recursive patterns support focused or broad runs while omitting test files.
- Adaptable execution: built-in Go tests and the external --exec path accommodate different test commands.
- Extensible operators: the Mutator interface and Cosmos SDK operators support specialized projects.
- No license fee: the MIT-licensed, Linux self-hosted tool has no paid plan or stated usage cap.
Cons
- Go and Linux only: it cannot serve teams working primarily in another language or desktop environment.
- False-positive risk: the checksum blacklist is explicitly described as poorly implemented, so suppression is unreliable.
- Operational responsibility: self-hosting and custom mutator or command work remain with the project team.
- Interpretation required: a mutation score is a signal, not proof that a test suite is dependable.
Alternatives
Browse the Mutation Testing Tools list for broader category coverage. Choose ArcMutate instead if you need Linux, macOS, Windows, or self-hosting, plus a freemium model with an $8-per-month Base plan and a free open-source license. MuJava is the better pick for Java users on Linux, macOS, or Windows; its open-source µJava plan is free.
Mutant suits teams wanting macOS support and a commercial option at $30 per developer per month, while public repositories retain the full open-source feature set. Pick Mutatest for a free MIT-licensed alternative on Linux, macOS, or Windows. pymute is a Linux free/open-source option installed with Cargo that requires Rust and Cargo.
LittleDarwin is a free Linux Java mutation-analysis framework supported through donations. MutPy offers free Linux self-hosted mutation testing with no paid plans or usage limits stated. Choose pytest-gremlins for a free MIT-licensed Python package on Linux requiring Python 3.11 or newer.
Verdict
go-mutesting is a strong choice for Go maintainers who want mutation evidence integrated with package tests, especially when surviving patches can guide focused test improvements. Its free MIT license, custom execution, and extensible mutators add practical flexibility. Look elsewhere if you need cross-platform support, another language, hosted delivery, or a more mature mechanism for handling false positives.
