check package - code.pfad.fr/check
import "code.pfad.fr/check"
Package check is a minimalist Go assertion package.
Although [assert libraries are frowned upon] by the Go team, this package aims at reducing the boilerplate while not getting in the way of your tests. Importantly:
assert libraries are frowned upon
- the tests will [keep going], unless specifically asked not to (to prevent a panic, for instance)
- the failure message can be expanded (to [identify the function and input] or [print diffs]), without polluting the output on equality
keep going
identify the function and input
print diffs
Dedicated to the public domain.
Example
// SPDX-FileCopyrightText: 2024 Olivier Charvin <git@olivier.pfad.fr>
// SPDX-License-Identifier: CC0-1.0
package main
import (
"testing"
"code.pfad.fr/check"
)
func testExample(t *testing.T) {
check.Equal(t, 2, 1+1) // simple equality check. Continues execution on inequality (test will fail)
obj, err := newObj()
check.Equal(t, nil, err).Fatal() // Fatal will stop the test on inequality (by calling t.FailNow)
check.Equal(t, 1, len(obj.Answers)).
Log("wrong answer size") // Log argument will only be printed on inequality
// EqualSlice will print a unified diff on inequality
check.EqualSlice(t, []int{42}, obj.Answers).
Logf("question: %q", "Ultimate Question"). // Printf syntax also is also supported for Log
Fatal() // Methods can be chained
// EqualDeep allows to compare complex structure.
// To print a unified diff, you can use the output of go-cmp as a Log argument:
// import "github.com/google/go-cmp/cmp"
expectedObj := o{}
check.EqualDeep(t, expectedObj, obj).
Log(cmp.Diff(expectedObj, obj))
}
// ✂ -- ignore anything below this line (tricks to show the test in the documentation as an example) -- ✂
func newObj() (o, error) { return o{}, nil }
func main() { _ = testExample }
type o struct{ Answers []int }
var cmp = struct{ Diff func(x, y any) string }{Diff: func(x, y any) string { return "" }}
Types
type Failure
type Failure struct {
// contains filtered or unexported fields
}
Failure allows logging more information in case of failure. All method calls will be no-op on nil (when the check succeeded).
func Equal
func Equal[T comparable](t testing.TB, want, got T) *Failure
Equal calls t.Error if want != got.
func EqualDeep
func EqualDeep[T any](t testing.TB, want, got T) *Failure
EqualDeep calls t.Error if .
reflect.DeepEqual
func EqualSlice
func EqualSlice[T comparable](t testing.TB, want, got []T) *Failure
EqualSlice is the slice version of [Equal]. Calls t.Error if want != got with an unified diff.
func True
func True(t testing.TB, got bool, args ...any) *Failure
True calls t.Error with the given args as message if got is not true.
func (*Failure) Fatal
func (f *Failure) Fatal()
Fatal stops the test execution if the Failure is not nil (no-op otherwise), see [testing.T.FailNow].
testing.T.FailNow
func (*Failure) Log
func (f *Failure) Log(args ...any) *Failure
Log formats its arguments using default formatting, analogous to Println, and records the text in the error log if the Failure is not nil (no-op otherwise).
func (*Failure) Logf
func (f *Failure) Logf(format string, args ...any) *Failure
Logf formats its arguments according to the format, analogous to Printf, and records the text in the error log if the Failure is not nil (no-op otherwise)
Files
check.go
diff.go
Forge
https://codeberg.org/pfad.fr/check
git clone
https://codeberg.org/pfad.fr/check.git
git@codeberg.org:pfad.fr/check.git