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:

• 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

Dedicated to the public domain.

Example

// SPDX-FileCopyrightText: 2024 Olivier Charvin 
// 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 .

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].

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

Forge

git clone

https://codeberg.org/pfad.fr/check.git
git@codeberg.org:pfad.fr/check.git