go-mutesting

go-mutesting is a free, MIT-licensed framework for checking how well tests catch changes to Go code. It generates mutations and reports a score based on how many the test suite kills. Targets can be Go files, directories, or packages, including recursive `...` patterns; `_test` files are excluded. By default, the tool changes the original file, runs that package’s tests, and reports whether the mutation was caught. A surviving mutation is accompanied by a source patch. Users can instead set an external command with `--exec`; environment variables describe the mutation and the command’s exit code indicates whether it was killed, survived, skipped, or had an unknown result. Built-in mutators cover branches, comparisons, boolean expressions, statement removal, and Cosmos SDK arithmetic and comparisons. Developers can add mutators through the Mutator interface and register them for the binary. The README describes mutation testing as an addition to automatic test suites and notes that false positives can occur. Its checksum blacklist can ignore some false positives, but is described as poorly implemented because source changes alter checksums. The project supports Linux and self-hosted use.

go-mutesting offers configurable mutation checks for Go tests, including custom execution and operators. Its own guidance positions the results as supplementary because false positives can occur.

It suits Go developers who want to find code changes their tests fail to catch, or compare automatically generated and manually written test suites. It can supplement an existing test suite using Go package tests or a custom command.

go-mutesting is a mutation testing framework for Go code that checks whether tests catch generated changes. It best suits developers who want to assess Go package tests or run a custom test command against mutations. Its reports can make gaps visible, but false positives mean results need judgment.

Overview

The tool targets Go source files, directories, or packages, including recursive ... patterns, and skips _test files. By default, it replaces the original file with a mutation, runs that package’s tests, and records whether the change was killed. A mutation score summarizes how many generated changes the suite catches; patches for surviving mutants show the code change that escaped detection.

This is a narrow, Go-only tool rather than a broad testing platform. It is designed to add a mutation check to an automatic test suite, and can also help compare automatically generated tests with manually written ones. Mutation results are evidence of test behavior, not a guarantee of test quality: the project cautions that false positives can occur and recommends using the tool as a supplement.

Key features

Operators and reports

Built-in mutators change branches, comparisons, boolean expressions, and statements. Cosmos SDK projects also get arithmetic and comparison mutations. For teams whose needs do not fit those operators, custom mutators can be implemented through the Mutator interface and registered with the binary. That flexibility is useful for specialized code, though it requires development work.

Each mutation is reported as tested or otherwise categorized by outcome, and surviving changes come with a source patch. This makes the output actionable for reviewing uncovered behavior. The checksum blacklist can ignore false positives, but the project warns that source changes alter checksums and calls the feature poorly implemented, which limits its reliability.

Test execution

Go package tests run by default. An external command can instead be supplied with --exec; environment variables describe each mutation, and exit codes report whether it was killed, remained alive, was skipped, or had an unknown outcome. This makes the workflow adaptable to other test runners, provided the command can interpret those variables and return the expected statuses.

Pricing

go-mutesting is free: its plan costs nothing and the project is MIT-licensed. There is no paid tier or trial to weigh against that option. The tradeoff is a self-hosted tool for Go rather than a hosted testing service or a multi-language product.

Platforms

The listed platform is Linux, with self-hosted use. Go is the only supported language, and Go package tests are the built-in test framework. Teams running other test commands can use --exec, but the tool’s mutation analysis remains focused on Go code.

Who it's for

go-mutesting is a practical fit for Go developers who already run package tests and want specific surviving changes to guide test improvements. It can also suit teams with custom test commands or specialized mutation needs if they are prepared to wire up execution or implement mutators.

It is a weaker fit for teams seeking a polished cross-language platform, or anyone expecting a mutation score to replace other test-suite checks.

Pros and cons

• Free and MIT-licensed: teams can add mutation checks without a software subscription.
• Useful surviving-mutant patches: reports show the source change tests failed to catch, giving developers a concrete lead.
• Flexible execution and extension: external commands and custom mutators accommodate workflows beyond the defaults, with setup and implementation effort.
• Go-only, Linux and self-hosted: the scope suits Go projects but excludes teams that need broader language or platform coverage.
• False-positive handling is limited: the checksum blacklist is described as poorly implemented, so it may not reliably filter results.

Alternatives

Mutation Testing Tools is a useful place to compare options across the category.

For Go code, go-mutesting keeps the focus on Go package tests and custom mutators. Choose ArcMutate if you need a multi-platform option: it supports Linux, macOS, Windows, and self-hosted use, with a free open-source-project license and an $8 a month Base plan.

LittleDarwin is a free, open-source Linux alternative for Java mutation analysis. Mutant is another Linux and macOS option, with full features for public repositories at no cost and commercial monthly pricing of $30 a month per developer.

MutPy is a free Linux option for a different mutation-testing setup. pymute is a free Linux alternative installed with Cargo and requiring Rust and Cargo. pytest-gremlins is a free Linux package for Python 3.11 and later.

MuJava is a free, open-source option for Linux, macOS, and Windows. Mutatest is another free MIT-licensed option supporting those three platforms.

Verdict

Choose go-mutesting if you maintain Go code and want a free, self-hosted way to see which generated changes your tests miss, especially when surviving patches can guide follow-up work. Look elsewhere if you need mutation analysis beyond Go or want a more dependable way to filter false positives; its own guidance makes clear that results belong alongside a broader test strategy.