assert
package module
This package is not in the latest version of its module.
Go to latest Published: Aug 22, 2026 License: MITDetails
-
Valid go.mod file
The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
-
Redistributable license
Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
-
Tagged version
Modules with tagged versions give importers more predictable builds.
-
Stable version
When a project reaches major version v1 it is considered stable.
- Learn more about best practices
Repository
Links
Open Source Insights
- README
-
Documentation
- Overview
- Index
- Constants
- Variables
-
Functions
- AllocsPerRun(tb, runs, f, allocs, opts)
- BytesContains(tb, b, subslice, opts)
- BytesEqual(tb, b1, b2, opts)
- BytesEqualFold(tb, b1, b2, opts)
- BytesHasPrefix(tb, b, prefix, opts)
- BytesHasSuffix(tb, b, suffix, opts)
- BytesNotContains(tb, b, subslice, opts)
- BytesNotEqual(tb, b1, b2, opts)
- BytesNotEqualFold(tb, b1, b2, opts)
- BytesNotHasPrefix(tb, b, prefix, opts)
- BytesNotHasSuffix(tb, b, suffix, opts)
- ChanEmpty(tb, c, opts)
- ChanLen(tb, c, l, opts)
- ChanNil(tb, c, opts)
- ChanNotEmpty(tb, c, opts)
- ChanNotNil(tb, c, opts)
- ChanRecvEmpty(tb, c, opts)
- ChanRecvLen(tb, c, l, opts)
- ChanRecvNil(tb, c, opts)
- ChanRecvNotEmpty(tb, c, opts)
- ChanRecvNotNil(tb, c, opts)
- ChanSendEmpty(tb, c, opts)
- ChanSendLen(tb, c, l, opts)
- ChanSendNil(tb, c, opts)
- ChanSendNotEmpty(tb, c, opts)
- ChanSendNotNil(tb, c, opts)
- Condition(tb, f, opts)
- DeepEqual(tb, v1, v2, opts)
- Equal(tb, v1, v2, opts)
- Error(tb, err, opts)
- ErrorAs(tb, err, target, opts)
- ErrorAsType(tb, err, opts)
- ErrorContains(tb, err, substr, opts)
- ErrorEqual(tb, err, message, opts)
- ErrorIs(tb, err, target, opts)
- ErrorNotIs(tb, err, target, opts)
- Fail(tb, name, msg, stackSkip, opts)
- False(tb, v, opts)
- FloatInf(tb, f, sign, opts)
- FloatNaN(tb, f, opts)
- FloatNotInf(tb, f, sign, opts)
- FloatNotNaN(tb, f, opts)
- Greater(tb, v1, v2, opts)
- GreaterOrEqual(tb, v1, v2, opts)
- Less(tb, v1, v2, opts)
- LessOrEqual(tb, v1, v2, opts)
- MapEmpty(tb, m, opts)
- MapEqual(tb, m1, m2, opts)
- MapLen(tb, m, l, opts)
- MapNil(tb, m, opts)
- MapNotEmpty(tb, m, opts)
- MapNotEqual(tb, m1, m2, opts)
- MapNotNil(tb, m, opts)
- Negative(tb, v, opts)
- NewDeepEqualerWithComparator(cr)
- NoError(tb, err, opts)
- NotDeepEqual(tb, v1, v2, opts)
- NotEqual(tb, v1, v2, opts)
- NotPanics(tb, f, opts)
- NotType(tb, v, opts)
- NotZero(tb, v, opts)
- Panics(tb, f, opts)
- Positive(tb, v, opts)
- RegexpMatch(tb, rs, s, opts)
- RegexpNotMatch(tb, rs, s, opts)
- SliceContains(tb, s, v, opts)
- SliceElementsMatch(tb, s1, s2, opts)
- SliceEmpty(tb, s, opts)
- SliceEqual(tb, s1, s2, opts)
- SliceLen(tb, s, l, opts)
- SliceNil(tb, s, opts)
- SliceNotContains(tb, s, v, opts)
- SliceNotEmpty(tb, s, opts)
- SliceNotEqual(tb, s1, s2, opts)
- SliceNotNil(tb, s, opts)
- StringContains(tb, s, substr, opts)
- StringEqualFold(tb, s1, s2, opts)
- StringHasPrefix(tb, s, prefix, opts)
- StringHasSuffix(tb, s, suffix, opts)
- StringLen(tb, s, l, opts)
- StringNotContains(tb, s, substr, opts)
- StringNotHasPrefix(tb, s, prefix, opts)
- StringNotHasSuffix(tb, s, suffix, opts)
- True(tb, v, opts)
- Type(tb, v, opts)
- Zero(tb, v, opts)
- Types
- Source Files
- Directories
README
¶
Assert
Go test assertion library.
Features
- Test assertion (equal, comparison, nil, empty, length, error, etc...)
- No reflection (uses generics)
- Customization (print and compare values)
- Auto-updating assertions (snapshot testing)
Assertions
A simple assertion:
assert.Equal(t, value, 1)
By default, assertions fail with Fatal(). It can be changed with the Report() option:
assert.Equal(t, value, 1, assert.ReportError())
The report message can be customized:
assert.Equal(t, value, 1, assert.MessageWrap("test"))
Why?
This assertion library is an experiment to see if it is possible to do better than github.com/stretchr/testify, by using generics.
Here is an example of an issue with github.com/stretchr/testify:
func Test(t *testing.T) {
value := getValue()
require.Equal(t, 1, value)
}
func getValue() int64 {
return 1
}
Surprisingly, this test fails with this error:
Error: Not equal: expected: int(1) actual : int64(1)
This issue is caused by the types, which are not identical (the 1 constant is an int and not an int64), and it's possible to fix it:
Convert the value to int64:
require.Equal(t, int64(1), value)
Use EqualValues() which converts the values to the same type:
require.EqualValues(t, 1, value)
But the internal implementation is not simple: it requires heavy usage of reflection, and the code is quite complex.
What if we could simply use the == operator? This is the solution chosen by this library. It uses generics to do the comparison, and it works with any comparable type:
func Equal[T comparable](tb testing.TB, v1, v2 T, opts ...Option) bool {
tb.Helper()
ok := v1 == v2
if !ok {
Fail(...)
}
return ok
}
assert.Equal(t, 1, value)
The constant 1 is automatically converted to the type of the value variable without using reflection.
However, this approach has a limitation: it requires writing a different assertion function for each "kind" (map, slice, etc...).
Customization
The default behavior can be customized:
- DeepEqualer allows customizing how values are compared with DeepEqual().
- ValueStringer allows customizing how values (including errors) are printed.
Auto-updating assertions
The assertauto sub-package provides assertions that automatically update their expected values. It compares actual values against expected values stored in files, and is useful for snapshot testing.
Unlike assert.Equal(), the expected value is not passed to the function but stored in a file:
assertauto.Equal(t, value)
To generate or update the expected values, run the tests with the environment variable ASSERTAUTO_UPDATE=true:
ASSERTAUTO_UPDATE=true go test ./...
The expected values are stored in the _assertauto directory, relative to the tested package. Each test creates a file named after the test, with the .txt extension. Values from the same test are stored sequentially in the same file. The storage directory can be changed with the environment variable ASSERTAUTO_DIRECTORY.
It also provides AllocsPerRun() to assert the number of allocations of a function.
The value stringer and the assert options can be customized with ValueStringer() and AssertOptions().
FAQ
Why not use github.com/stretchr/testify?
I think it's a great library, but I wanted to try something different. I also wanted to try generics, and to see if it was possible to make an assertion library without reflection.
Where are Nil() and NotNil()?
- For slices use SliceNil() and SliceNotNil()
- For maps use MapNil() and MapNotNil()
- For comparable types use Zero() and NotZero()
Documentation
¶
Overview ¶
Package assert provides utilities to assert conditions in tests.
Assertion functions return a boolean value indicating whether the assertion succeeded.
By default, assertion failures are reported using testing.TB.Fatal. This can be customized with the Report() option.
Index ¶
- Variables
- func AllocsPerRun(tb testing.TB, runs int, f func(), allocs float64, opts ...Option) bool
- func BytesContains(tb testing.TB, b, subslice []byte, opts ...Option) bool
- func BytesEqual(tb testing.TB, b1, b2 []byte, opts ...Option) bool
- func BytesEqualFold(tb testing.TB, b1, b2 []byte, opts ...Option) bool
- func BytesHasPrefix(tb testing.TB, b, prefix []byte, opts ...Option) bool
- func BytesHasSuffix(tb testing.TB, b, suffix []byte, opts ...Option) bool
- func BytesNotContains(tb testing.TB, b, subslice []byte, opts ...Option) bool
- func BytesNotEqual(tb testing.TB, b1, b2 []byte, opts ...Option) bool
- func BytesNotEqualFold(tb testing.TB, b1, b2 []byte, opts ...Option) bool
- func BytesNotHasPrefix(tb testing.TB, b, prefix []byte, opts ...Option) bool
- func BytesNotHasSuffix(tb testing.TB, b, suffix []byte, opts ...Option) bool
- func ChanEmpty[T any](tb testing.TB, c chan T, opts ...Option) bool
- func ChanLen[T any](tb testing.TB, c chan T, l int, opts ...Option) bool
- func ChanNil[T any](tb testing.TB, c chan T, opts ...Option) bool
- func ChanNotEmpty[T any](tb testing.TB, c chan T, opts ...Option) bool
- func ChanNotNil[T any](tb testing.TB, c chan T, opts ...Option) bool
- func ChanRecvEmpty[T any](tb testing.TB, c <-chan T, opts ...Option) bool
- func ChanRecvLen[T any](tb testing.TB, c <-chan T, l int, opts ...Option) bool
- func ChanRecvNil[T any](tb testing.TB, c <-chan T, opts ...Option) bool
- func ChanRecvNotEmpty[T any](tb testing.TB, c <-chan T, opts ...Option) bool
- func ChanRecvNotNil[T any](tb testing.TB, c <-chan T, opts ...Option) bool
- func ChanSendEmpty[T any](tb testing.TB, c chan<- T, opts ...Option) bool
- func ChanSendLen[T any](tb testing.TB, c chan<- T, l int, opts ...Option) bool
- func ChanSendNil[T any](tb testing.TB, c chan<- T, opts ...Option) bool
- func ChanSendNotEmpty[T any](tb testing.TB, c chan<- T, opts ...Option) bool
- func ChanSendNotNil[T any](tb testing.TB, c chan<- T, opts ...Option) bool
- func Condition(tb testing.TB, f func() bool, opts ...Option) bool
- func DeepEqual[T any](tb testing.TB, v1, v2 T, opts ...Option) bool
- func Equal[T comparable](tb testing.TB, v1, v2 T, opts ...Option) bool
- func Error(tb testing.TB, err error, opts ...Option) bool
- func ErrorAs(tb testing.TB, err error, target any, opts ...Option) bool
- func ErrorAsType[E error](tb testing.TB, err error, opts ...Option) (E, bool)
- func ErrorContains(tb testing.TB, err error, substr string, opts ...Option) bool
- func ErrorEqual(tb testing.TB, err error, message string, opts ...Option) bool
- func ErrorIs(tb testing.TB, err, target error, opts ...Option) bool
- func ErrorNotIs(tb testing.TB, err, target error, opts ...Option) bool
- func Fail(tb testing.TB, name string, msg string, stackSkip int, opts ...Option)
- func False(tb testing.TB, v bool, opts ...Option) bool
- func FloatInf[T Float](tb testing.TB, f T, sign int, opts ...Option) bool
- func FloatNaN[T Float](tb testing.TB, f T, opts ...Option) bool
- func FloatNotInf[T Float](tb testing.TB, f T, sign int, opts ...Option) bool
- func FloatNotNaN[T Float](tb testing.TB, f T, opts ...Option) bool
- func Greater[T cmp.Ordered](tb testing.TB, v1, v2 T, opts ...Option) bool
- func GreaterOrEqual[T cmp.Ordered](tb testing.TB, v1, v2 T, opts ...Option) bool
- func Less[T cmp.Ordered](tb testing.TB, v1, v2 T, opts ...Option) bool
- func LessOrEqual[T cmp.Ordered](tb testing.TB, v1, v2 T, opts ...Option) bool
- func MapEmpty[M ~map[K]V, K comparable, V any](tb testing.TB, m M, opts ...Option) bool
- func MapEqual[M1, M2 ~map[K]V, K, V comparable](tb testing.TB, m1 M1, m2 M2, opts ...Option) bool
- func MapLen[M ~map[K]V, K comparable, V any](tb testing.TB, m M, l int, opts ...Option) bool
- func MapNil[M ~map[K]V, K comparable, V any](tb testing.TB, m M, opts ...Option) bool
- func MapNotEmpty[M ~map[K]V, K comparable, V any](tb testing.TB, m M, opts ...Option) bool
- func MapNotEqual[M1, M2 ~map[K]V, K, V comparable](tb testing.TB, m1 M1, m2 M2, opts ...Option) bool
- func MapNotNil[M ~map[K]V, K comparable, V any](tb testing.TB, m M, opts ...Option) bool
- func Negative[T SignedNumber](tb testing.TB, v T, opts ...Option) bool
- func NewDeepEqualerWithComparator(cr *compare.Comparator) func(v1, v2 any) (string, bool)
- func NoError(tb testing.TB, err error, opts ...Option) bool
- func NotDeepEqual[T any](tb testing.TB, v1, v2 T, opts ...Option) bool
- func NotEqual[T comparable](tb testing.TB, v1, v2 T, opts ...Option) bool
- func NotPanics(tb testing.TB, f func(), opts ...Option) (ok bool)
- func NotType[T any](tb testing.TB, v any, opts ...Option) bool
- func NotZero[T comparable](tb testing.TB, v T, opts ...Option) bool
- func Panics(tb testing.TB, f func(), opts ...Option) (rec any, ok bool)
- func Positive[T SignedNumber](tb testing.TB, v T, opts ...Option) bool
- func RegexpMatch[RS RegexpString](tb testing.TB, rs RS, s string, opts ...Option) bool
- func RegexpNotMatch[RS RegexpString](tb testing.TB, rs RS, s string, opts ...Option) bool
- func SliceContains[S ~[]E, E comparable](tb testing.TB, s S, v E, opts ...Option) bool
- func SliceElementsMatch[S ~[]E, E comparable](tb testing.TB, s1, s2 S, opts ...Option) bool
- func SliceEmpty[S ~[]E, E any](tb testing.TB, s S, opts ...Option) bool
- func SliceEqual[S ~[]E, E comparable](tb testing.TB, s1, s2 S, opts ...Option) bool
- func SliceLen[S ~[]E, E any](tb testing.TB, s S, l int, opts ...Option) bool
- func SliceNil[S ~[]E, E any](tb testing.TB, s S, opts ...Option) bool
- func SliceNotContains[S ~[]E, E comparable](tb testing.TB, s S, v E, opts ...Option) bool
- func SliceNotEmpty[S ~[]E, E any](tb testing.TB, s S, opts ...Option) bool
- func SliceNotEqual[S ~[]E, E comparable](tb testing.TB, s1, s2 S, opts ...Option) bool
- func SliceNotNil[S ~[]E, E any](tb testing.TB, s S, opts ...Option) bool
- func StringContains(tb testing.TB, s, substr string, opts ...Option) bool
- func StringEqualFold(tb testing.TB, s1, s2 string, opts ...Option) bool
- func StringHasPrefix(tb testing.TB, s, prefix string, opts ...Option) bool
- func StringHasSuffix(tb testing.TB, s, suffix string, opts ...Option) bool
- func StringLen(tb testing.TB, s string, l int, opts ...Option) bool
- func StringNotContains(tb testing.TB, s, substr string, opts ...Option) bool
- func StringNotHasPrefix(tb testing.TB, s, prefix string, opts ...Option) bool
- func StringNotHasSuffix(tb testing.TB, s, suffix string, opts ...Option) bool
- func True(tb testing.TB, v bool, opts ...Option) bool
- func Type[T any](tb testing.TB, v any, opts ...Option) (T, bool)
- func Zero[T comparable](tb testing.TB, v T, opts ...Option) bool
- type Float
- type Option
- func Lazy(f func() Option) Option
- func Message(msg string) Option
- func MessageTransform(f func(msg string) string) Option
- func MessageWrap(msg string) Option
- func MessageWrapf(format string, args ...any) Option
- func Messagef(format string, args ...any) Option
- func Options(opts ...Option) Option
- func Report(f ReportFunc) Option
- func ReportError() Option
- func ReportFatal() Option
- func ReportLog() Option
- func ReportSkip() Option
- func ShowStack(show bool) Option
- type RegexpString
- type ReportFunc
- type SignedNumber
Constants ¶
This section is empty.
Variables ¶
var DeepEqualer atomicutil.Value[func(v1, v2 any) (string, bool)]
DeepEqualer is a function that checks if two values are deeply equal.
By default, it uses compare.DefaultComparator.
var DefaultReport atomicutil.Value[ReportFunc]
DefaultReport is the default ReportFunc used for assertion failures. See the Report option.
By default it uses testing.TB.Fatal.
var DefaultShowStack atomic.Bool
DefaultShowStack is the default value used to show stack traces on assertion failures. See the ShowStack option.
By default it is true.
var ValueStringer atomicutil.Value[func(any) string]
ValueStringer is a function that returns the string representation of a value.
By default, it uses pretty.String.
Functions ¶
func AllocsPerRun ¶ added in v0.1.2
AllocsPerRun asserts that a function allocates a certain number of times per run.
If the race detector is enabled, this function does nothing and returns true. This prevents tests from failing due to the increased number of allocations.
func BytesContains ¶ added in v0.6.1
BytesContains asserts that b contains subslice. It uses bytes.Contains to check if subslice is contained in b.
func BytesEqual ¶
BytesEqual asserts that b1 and b2 are equal. It uses bytes.Equal to compare the two byte slices.
func BytesEqualFold ¶ added in v0.15.0
BytesEqualFold asserts that b1 and b2 are equal, ignoring case. It uses bytes.EqualFold to compare the two byte slices.
func BytesHasPrefix ¶ added in v0.12.1
BytesHasPrefix asserts that b begins with prefix. It uses bytes.HasPrefix to check if b begins with prefix.
func BytesHasSuffix ¶ added in v0.12.1
BytesHasSuffix asserts that b ends with suffix. It uses bytes.HasSuffix to check if b ends with suffix.
func BytesNotContains ¶ added in v0.6.1
BytesNotContains asserts that b does not contain subslice. It uses bytes.Contains to check if subslice is contained in b.
func BytesNotEqual ¶
BytesNotEqual asserts that b1 and b2 are not equal. It uses bytes.Equal to compare the two byte slices.
func BytesNotEqualFold ¶ added in v0.15.0
BytesNotEqualFold asserts that b1 and b2 are not equal, ignoring case. It uses bytes.EqualFold to compare the two byte slices.
func BytesNotHasPrefix ¶ added in v0.12.1
BytesNotHasPrefix asserts that b does not begin with prefix. It uses bytes.HasPrefix to check if b begins with prefix.
func BytesNotHasSuffix ¶ added in v0.12.1
BytesNotHasSuffix asserts that b does not end with suffix. It uses bytes.HasSuffix to check if b ends with suffix.
func ChanNotEmpty ¶
ChanNotEmpty asserts that c is not empty.
func ChanNotNil ¶
ChanNotNil asserts that c is not nil.
func ChanRecvEmpty ¶ added in v0.15.4
ChanRecvEmpty asserts that c is empty.
func ChanRecvLen ¶ added in v0.15.4
ChanRecvLen asserts that c has length l.
func ChanRecvNil ¶ added in v0.15.4
ChanRecvNil asserts that c is nil.
func ChanRecvNotEmpty ¶ added in v0.15.4
ChanRecvNotEmpty asserts that c is not empty.
func ChanRecvNotNil ¶ added in v0.15.4
ChanRecvNotNil asserts that c is not nil.
func ChanSendEmpty ¶ added in v0.15.4
ChanSendEmpty asserts that c is empty.
func ChanSendLen ¶ added in v0.15.4
ChanSendLen asserts that c has length l.
func ChanSendNil ¶ added in v0.15.4
ChanSendNil asserts that c is nil.
func ChanSendNotEmpty ¶ added in v0.15.4
ChanSendNotEmpty asserts that c is not empty.
func ChanSendNotNil ¶ added in v0.15.4
ChanSendNotNil asserts that c is not nil.
func DeepEqual ¶
DeepEqual asserts that v1 and v2 are deeply equal according to DeepEqualer.
func Equal ¶
func Equal[T comparable](tb testing.TB, v1, v2 T, opts ...Option) bool
Equal asserts that v1 == v2.
For floating-point values, note that NaN != NaN, so Equal will always fail when comparing NaN to itself. Use FloatNaN or FloatNotNaN instead.
func ErrorAs ¶
ErrorAs asserts that errors.As returns true.
target must be a non-nil pointer to a type that implements error, or to any interface type.
func ErrorAsType ¶ added in v0.13.0
ErrorAsType asserts that errors.AsType returns true and returns the error of type E.
func ErrorContains ¶
ErrorContains asserts that the result of [error.Error] contains substr.
func ErrorEqual ¶
ErrorEqual asserts that the result of [error.Error] is equal to message.
func ErrorNotIs ¶
ErrorNotIs asserts that errors.Is returns false.
func Fail ¶
Fail handles assertion failure. It calls the ReportFunc with the given message.
func FloatInf ¶ added in v0.14.0
FloatInf asserts that f is an infinity according to sign. If sign > 0, asserts that f is positive infinity. If sign < 0, asserts that f is negative infinity. If sign == 0, asserts that f is either positive or negative infinity.
func FloatNotInf ¶ added in v0.14.0
FloatNotInf asserts that f is not an infinity according to sign. If sign > 0, asserts that f is not positive infinity. If sign < 0, asserts that f is not negative infinity. If sign == 0, asserts that f is not any infinity (finite value).
func FloatNotNaN ¶ added in v0.14.0
FloatNotNaN asserts that f is not NaN (not-a-number).
func GreaterOrEqual ¶
GreaterOrEqual asserts that v1 >= v2.
func LessOrEqual ¶
LessOrEqual asserts that v1 <= v2.
func MapEqual ¶
func MapEqual[M1, M2 ~map[K]V, K, V comparable](tb testing.TB, m1 M1, m2 M2, opts ...Option) bool
MapEqual asserts that m1 and m2 are equal.
func MapNotEmpty ¶
MapNotEmpty asserts that m is not empty.
func MapNotEqual ¶
func MapNotEqual[M1, M2 ~map[K]V, K, V comparable](tb testing.TB, m1 M1, m2 M2, opts ...Option) bool
MapNotEqual asserts that m1 and m2 are not equal.
func Negative ¶
func Negative[T SignedNumber](tb testing.TB, v T, opts ...Option) bool
Negative asserts that the value is negative.
func NewDeepEqualerWithComparator ¶ added in v0.6.0
func NewDeepEqualerWithComparator(cr *compare.Comparator) func(v1, v2 any) (string, bool)
NewDeepEqualerWithComparator creates a new DeepEqualer with a custom compare.Comparator.
func NotDeepEqual ¶
NotDeepEqual asserts that v1 and v2 are not deeply equal according to DeepEqualer.
func NotEqual ¶
func NotEqual[T comparable](tb testing.TB, v1, v2 T, opts ...Option) bool
NotEqual asserts that v1 != v2.
func NotPanics ¶
NotPanics asserts that the code inside the function f does not panic.
It returns true if no panic occurred, or false if f panicked.
func NotZero ¶
func NotZero[T comparable](tb testing.TB, v T, opts ...Option) bool
NotZero asserts that v != zero.
func Panics ¶
Panics asserts that the code inside the function f panics.
It returns the recovered value and true if a panic occurred, or nil and false if f did not panic.
func Positive ¶
func Positive[T SignedNumber](tb testing.TB, v T, opts ...Option) bool
Positive asserts that the value is positive.
func RegexpMatch ¶
RegexpMatch asserts that rs matches s.
func RegexpNotMatch ¶
RegexpNotMatch asserts that rs doesn't match s.
func SliceContains ¶
func SliceContains[S ~[]E, E comparable](tb testing.TB, s S, v E, opts ...Option) bool
SliceContains asserts that s contains v.
func SliceElementsMatch ¶ added in v0.15.4
func SliceElementsMatch[S ~[]E, E comparable](tb testing.TB, s1, s2 S, opts ...Option) bool
SliceElementsMatch asserts that s1 and s2 contain the same elements, regardless of order.
func SliceEmpty ¶
SliceEmpty asserts that s is empty.
func SliceEqual ¶
func SliceEqual[S ~[]E, E comparable](tb testing.TB, s1, s2 S, opts ...Option) bool
SliceEqual asserts that s1 and s2 are equal.
func SliceNotContains ¶
func SliceNotContains[S ~[]E, E comparable](tb testing.TB, s S, v E, opts ...Option) bool
SliceNotContains asserts that s does not contain v.
func SliceNotEmpty ¶
SliceNotEmpty asserts that s is not empty.
func SliceNotEqual ¶
func SliceNotEqual[S ~[]E, E comparable](tb testing.TB, s1, s2 S, opts ...Option) bool
SliceNotEqual asserts that s1 and s2 are not equal.
func SliceNotNil ¶
SliceNotNil asserts that s is not nil.
func StringContains ¶
StringContains asserts that s contains substr.
func StringEqualFold ¶
StringEqualFold asserts that s1 and s2 are equal, ignoring case.
func StringHasPrefix ¶
StringHasPrefix asserts that s begins with prefix.
func StringHasSuffix ¶
StringHasSuffix asserts that s ends with suffix.
func StringNotContains ¶
StringNotContains asserts that s does not contain substr.
func StringNotHasPrefix ¶ added in v0.14.1
StringNotHasPrefix asserts that s does not begin with prefix.
func StringNotHasSuffix ¶ added in v0.14.1
StringNotHasSuffix asserts that s does not end with suffix.
func Zero ¶
func Zero[T comparable](tb testing.TB, v T, opts ...Option) bool
Zero asserts that v == zero.
Types ¶
type Option ¶
type Option func(*options)
Option is an option for an assertion.
func Lazy ¶ added in v0.5.0
Lazy returns an Option that defers the evaluation of the option.
It helps to reduce allocations when the option is not used.
func MessageTransform ¶
MessageTransform returns an Option that adds a message transform function. The function is called before the ReportFunc. If several functions are added, they are called in order.
func MessageWrap ¶
MessageWrap returns an Option that wraps the message. The final message is "<msg>: <original message>".
func MessageWrapf ¶
MessageWrapf returns an Option that wraps the message. The final message is "<format msg>: <original message>".
func Report ¶
func Report(f ReportFunc) Option
Report returns an Option that sets the ReportFunc. The default value is DefaultReport.
func ReportError ¶ added in v0.9.0
func ReportError() Option
ReportError returns an Option that sets the ReportFunc to testing.TB.Error.
func ReportFatal ¶ added in v0.9.0
func ReportFatal() Option
ReportFatal returns an Option that sets the ReportFunc to testing.TB.Fatal.
func ReportLog ¶ added in v0.9.0
func ReportLog() Option
ReportLog returns an Option that sets the ReportFunc to testing.TB.Log.
func ReportSkip ¶ added in v0.9.0
func ReportSkip() Option
ReportSkip returns an Option that sets the ReportFunc to testing.TB.Skip.
type RegexpString ¶
RegexpString is a type that can be either a *regexp.Regexp or a string.
If it's a string, it's automatically compiled to a *regexp.Regexp.
type ReportFunc ¶
ReportFunc is a function that is called when an assertion fails.
It can be set to method expressions such as testing.TB.Fatal, testing.TB.Error, testing.TB.Skip, or testing.TB.Log. The default value is DefaultReport.
Source Files
¶
Directories
¶
| Path | Synopsis |
|---|---|
|
Package assertauto provides helpers to automatically update the expected values of test assertions.
|
Package assertauto provides helpers to automatically update the expected values of test assertions. |
|
internal
Package diff is a copy of https://pkg.go.dev/internal/diff.
|
Package diff is a copy of https://pkg.go.dev/internal/diff. |
|
Package asserttest provides utilities to test assertions.
|
Package asserttest provides utilities to test assertions. |