assert

func CallerInfo ¶

func CallerInfo() []string

CallerInfo returns an array of strings containing the file and line number of each stack frame leading from the current test to the assert call that failed.

func Condition ¶

func Condition(t T, comp func() bool, msgAndArgs ...any) bool

Condition uses a comparison function to assert a complex condition.

Usage ¶

assertions.Condition(t, func() bool { return myCondition })

Examples ¶

success:  func() bool { return true }
failure:  func() bool { return false }

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestCondition(t *testing.T)
	success := assert.Condition(t, func() bool {
		return true
	})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Conditionf ¶

func Conditionf(t T, comp func() bool, msg string, args ...any) bool

Conditionf is the same as Condition, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Consistently ¶ added in v2.4.0

func Consistently[C Conditioner](t T, condition C, timeout time.Duration, tick time.Duration, msgAndArgs ...any) bool

Consistently asserts that the given condition is always satisfied until timeout, periodically checking the target function at each tick.

Consistently ("always") imposes a stronger constraint than Eventually ("at least once"): it checks at every tick that every occurrence of the condition is satisfied, whereas Eventually succeeds on the first occurrence of a successful condition.

Usage ¶

assertions.Consistently(t, func() bool { return true }, time.Second, 10*time.Millisecond)

See also Eventually for details about using context and concurrency.

Alternative condition signature ¶

The simplest form of condition is:

func() bool

The semantics of the assertion are "always returns true".

To build more complex cases, a condition may also be defined as:

func(context.Context) error

It fails as soon as an error is returned before timeout expressing "always returns no error (nil)"

This is consistent with Eventually expressing "eventually returns no error (nil)".

It will be executed with the context of the assertion, which inherits the testing.T.Context and is cancelled on timeout.

Concurrency ¶

See Eventually.

Attention point ¶

See Eventually.

Examples ¶

success:  func() bool { return true }, 100*time.Millisecond, 20*time.Millisecond
failure:  func() bool { return false }, 100*time.Millisecond, 20*time.Millisecond

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"
	"time"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestConsistently(t *testing.T)
	success := assert.Consistently(t, func() bool {
		return true
	}, 100*time.Millisecond, 20*time.Millisecond)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

package main

import (
	"context"
	"fmt"
	"testing"
	"time"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // normally provided by test

	// Simulate a service that stays healthy.
	healthCheck := func(_ context.Context) error {
		return nil // always healthy
	}

	result := assert.Consistently(t, healthCheck, 100*time.Millisecond, 10*time.Millisecond)

	fmt.Printf("consistently healthy: %t", result)

}

Output:

consistently healthy: true

package main

import (
	"fmt"
	"sync/atomic"
	"testing"
	"time"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // normally provided by test

	// A counter that stays within bounds during the test.
	var counter atomic.Int32
	counter.Store(5)

	result := assert.Consistently(t, func() bool {
		return counter.Load() < 10
	}, 100*time.Millisecond, 10*time.Millisecond)

	fmt.Printf("consistently under limit: %t", result)

}

Output:

consistently under limit: true

func Consistentlyf ¶ added in v2.4.0

func Consistentlyf[C Conditioner](t T, condition C, timeout time.Duration, tick time.Duration, msg string, args ...any) bool

Consistentlyf is the same as Consistently, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Contains ¶

func Contains(t T, s any, contains any, msgAndArgs ...any) bool

Contains asserts that the specified string, list(array, slice...) or map contains the specified substring or element.

Usage ¶

assertions.Contains(t, "Hello World", "World")
assertions.Contains(t, []string{"Hello", "World"}, "World")
assertions.Contains(t, map[string]string{"Hello": "World"}, "Hello")

Examples ¶

success: []string{"A","B"}, "A"
failure: []string{"A","B"}, "C"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestContains(t *testing.T)
	success := assert.Contains(t, []string{"A", "B"}, "A")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Containsf ¶

func Containsf(t T, s any, contains any, msg string, args ...any) bool

Containsf is the same as Contains, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func DirExists ¶

func DirExists(t T, path string, msgAndArgs ...any) bool

DirExists checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists.

Usage ¶

assertions.DirExists(t, "path/to/directory")

Examples ¶

success: filepath.Join(testDataPath(),"existing_dir")
failure: filepath.Join(testDataPath(),"non_existing_dir")

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"path/filepath"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestDirExists(t *testing.T)
	success := assert.DirExists(t, filepath.Join(testDataPath(), "existing_dir"))
	fmt.Printf("success: %t\n", success)

}

func testDataPath() string {
	return filepath.Join("..", "internal", "assertions", "testdata")
}

Output:

success: true

func DirExistsf ¶

func DirExistsf(t T, path string, msg string, args ...any) bool

DirExistsf is the same as DirExists, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func DirNotExists ¶ added in v2.2.0

func DirNotExists(t T, path string, msgAndArgs ...any) bool

DirNotExists checks whether a directory does not exist in the given path. It fails if the path points to an existing _directory_ only.

Usage ¶

assertions.DirNotExists(t, "path/to/directory")

Examples ¶

success: filepath.Join(testDataPath(),"non_existing_dir")
failure: filepath.Join(testDataPath(),"existing_dir")

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"path/filepath"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestDirNotExists(t *testing.T)
	success := assert.DirNotExists(t, filepath.Join(testDataPath(), "non_existing_dir"))
	fmt.Printf("success: %t\n", success)

}

func testDataPath() string {
	return filepath.Join("..", "internal", "assertions", "testdata")
}

Output:

success: true

func DirNotExistsf ¶ added in v2.2.0

func DirNotExistsf(t T, path string, msg string, args ...any) bool

DirNotExistsf is the same as DirNotExists, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func ElementsMatch ¶

func ElementsMatch(t T, listA any, listB any, msgAndArgs ...any) (ok bool)

ElementsMatch asserts that the specified listA(array, slice...) is equal to specified listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, the number of appearances of each of them in both lists should match.

Usage ¶

assertions.ElementsMatch(t, []int{1, 3, 2, 3}, []int{1, 3, 3, 2})

Examples ¶

success: []int{1, 3, 2, 3}, []int{1, 3, 3, 2}
failure: []int{1, 2, 3}, []int{1, 2, 4}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestElementsMatch(t *testing.T)
	success := assert.ElementsMatch(t, []int{1, 3, 2, 3}, []int{1, 3, 3, 2})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func ElementsMatchT ¶ added in v2.2.0

func ElementsMatchT[E comparable](t T, listA []E, listB []E, msgAndArgs ...any) bool

ElementsMatchT asserts that the specified listA(array, slice...) is equal to specified listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, the number of appearances of each of them in both lists should match.

Usage ¶

assertions.ElementsMatchT(t, []int{1, 3, 2, 3}, []int{1, 3, 3, 2})

Examples ¶

success: []int{1, 3, 2, 3}, []int{1, 3, 3, 2}
failure: []int{1, 2, 3}, []int{1, 2, 4}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestElementsMatchT(t *testing.T)
	success := assert.ElementsMatchT(t, []int{1, 3, 2, 3}, []int{1, 3, 3, 2})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func ElementsMatchTf ¶ added in v2.2.0

func ElementsMatchTf[E comparable](t T, listA []E, listB []E, msg string, args ...any) bool

ElementsMatchTf is the same as ElementsMatchT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func ElementsMatchf ¶

func ElementsMatchf(t T, listA any, listB any, msg string, args ...any) (ok bool)

ElementsMatchf is the same as ElementsMatch, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Empty ¶

func Empty(t T, object any, msgAndArgs ...any) bool

Empty asserts that the given value is "empty".

Zero values are "empty".

Arrays are "empty" if every element is the zero value of the type (stricter than "empty").

Slices, maps and channels with zero length are "empty".

Pointer values are "empty" if the pointer is nil or if the pointed value is "empty".

Usage ¶

assertions.Empty(t, obj)

Examples ¶

success: ""
failure: "not empty"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestEmpty(t *testing.T)
	success := assert.Empty(t, "")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Emptyf ¶

func Emptyf(t T, object any, msg string, args ...any) bool

Emptyf is the same as Empty, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Equal ¶

func Equal(t T, expected any, actual any, msgAndArgs ...any) bool

Equal asserts that two objects are equal.

Pointer variable equality is determined based on the equality of the referenced values (as opposed to the memory addresses).

Function equality cannot be determined and will always fail.

Usage ¶

assertions.Equal(t, 123, 123)

Examples ¶

success: 123, 123
failure: 123, 456

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestEqual(t *testing.T)
	success := assert.Equal(t, 123, 123)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func EqualError ¶

func EqualError(t T, err error, errString string, msgAndArgs ...any) bool

EqualError asserts that a function returned a non-nil error (i.e. an error) and that it is equal to the provided error.

Usage ¶

actualObj, err := SomeFunction()
assertions.EqualError(t, err,  expectedErrorString)

Examples ¶

success: ErrTest, "assert.ErrTest general error for testing"
failure: ErrTest, "wrong error message"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestEqualError(t *testing.T)
	success := assert.EqualError(t, assert.ErrTest, "assert.ErrTest general error for testing")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func EqualErrorf ¶

func EqualErrorf(t T, err error, errString string, msg string, args ...any) bool

EqualErrorf is the same as EqualError, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func EqualExportedValues ¶

func EqualExportedValues(t T, expected any, actual any, msgAndArgs ...any) bool

EqualExportedValues asserts that the types of two objects are equal and their public fields are also equal.

This is useful for comparing structs that have private fields that could potentially differ.

Function equality cannot be determined and will always fail.

Usage ¶

type S struct {
	Exported     	int
	notExported   	int
}
assertions.EqualExportedValues(t, S{1, 2}, S{1, 3}) => true
assertions.EqualExportedValues(t, S{1, 2}, S{2, 3}) => false

Examples ¶

success: &dummyStruct{A: "a", b: 1}, &dummyStruct{A: "a", b: 2}
failure: &dummyStruct{A: "a", b: 1}, &dummyStruct{A: "b", b: 1}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestEqualExportedValues(t *testing.T)
	success := assert.EqualExportedValues(t, &dummyStruct{A: "a", b: 1}, &dummyStruct{A: "a", b: 2})
	fmt.Printf("success: %t\n", success)

}

type dummyStruct struct {
	A string
	b int
}

Output:

success: true

func EqualExportedValuesf ¶

func EqualExportedValuesf(t T, expected any, actual any, msg string, args ...any) bool

EqualExportedValuesf is the same as EqualExportedValues, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func EqualT ¶ added in v2.2.0

func EqualT[V comparable](t T, expected V, actual V, msgAndArgs ...any) bool

EqualT asserts that two objects of the same comparable type are equal.

Pointer variable equality is determined based on the equality of the memory addresses (unlike Equal, but like Same).

Functions, slices and maps are not comparable. See also ComparisonOperators.

If you need to compare values of non-comparable types, or compare pointers by the value they point to, use Equal instead.

Usage ¶

assertions.EqualT(t, 123, 123)

Examples ¶

success: 123, 123
failure: 123, 456

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestEqualT(t *testing.T)
	success := assert.EqualT(t, 123, 123)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func EqualTf ¶ added in v2.2.0

func EqualTf[V comparable](t T, expected V, actual V, msg string, args ...any) bool

EqualTf is the same as EqualT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func EqualValues ¶

func EqualValues(t T, expected any, actual any, msgAndArgs ...any) bool

EqualValues asserts that two objects are equal or convertible to the larger type and equal.

Function equality cannot be determined and will always fail.

Usage ¶

assertions.EqualValues(t, uint32(123), int32(123))

Examples ¶

success: uint32(123), int32(123)
failure: uint32(123), int32(456)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestEqualValues(t *testing.T)
	success := assert.EqualValues(t, uint32(123), int32(123))
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func EqualValuesf ¶

func EqualValuesf(t T, expected any, actual any, msg string, args ...any) bool

EqualValuesf is the same as EqualValues, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Equalf ¶

func Equalf(t T, expected any, actual any, msg string, args ...any) bool

Equalf is the same as Equal, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Error ¶

func Error(t T, err error, msgAndArgs ...any) bool

Error asserts that a function returned a non-nil error (i.e. an error).

Usage ¶

actualObj, err := SomeFunction()
assertions.Error(t, err)

Examples ¶

success: ErrTest
failure: nil

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestError(t *testing.T)
	success := assert.Error(t, assert.ErrTest)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func ErrorAs ¶

func ErrorAs(t T, err error, target any, msgAndArgs ...any) bool

ErrorAs asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.

This is a wrapper for errors.As.

Usage ¶

assertions.ErrorAs(t, err, &target)

Examples ¶

success: fmt.Errorf("wrap: %w", &dummyError{}), new(*dummyError)
failure: ErrTest, new(*dummyError)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestErrorAs(t *testing.T)
	success := assert.ErrorAs(t, fmt.Errorf("wrap: %w", &dummyError{}), new(*dummyError))
	fmt.Printf("success: %t\n", success)

}

type dummyError struct {
}

func (d *dummyError) Error() string {
	return "dummy error"
}

Output:

success: true

func ErrorAsf ¶

func ErrorAsf(t T, err error, target any, msg string, args ...any) bool

ErrorAsf is the same as ErrorAs, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func ErrorContains ¶

func ErrorContains(t T, err error, contains string, msgAndArgs ...any) bool

ErrorContains asserts that a function returned a non-nil error (i.e. an error) and that the error contains the specified substring.

Usage ¶

actualObj, err := SomeFunction()
assertions.ErrorContains(t, err,  expectedErrorSubString)

Examples ¶

success: ErrTest, "general error"
failure: ErrTest, "not in message"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestErrorContains(t *testing.T)
	success := assert.ErrorContains(t, assert.ErrTest, "general error")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func ErrorContainsf ¶

func ErrorContainsf(t T, err error, contains string, msg string, args ...any) bool

ErrorContainsf is the same as ErrorContains, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func ErrorIs ¶

func ErrorIs(t T, err error, target error, msgAndArgs ...any) bool

ErrorIs asserts that at least one of the errors in err's chain matches target.

This is a wrapper for errors.Is.

Usage ¶

assertions.ErrorIs(t, err, io.EOF)

Examples ¶

success: fmt.Errorf("wrap: %w", io.EOF), io.EOF
failure: ErrTest, io.EOF

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"io"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestErrorIs(t *testing.T)
	success := assert.ErrorIs(t, fmt.Errorf("wrap: %w", io.EOF), io.EOF)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func ErrorIsf ¶

func ErrorIsf(t T, err error, target error, msg string, args ...any) bool

ErrorIsf is the same as ErrorIs, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Errorf ¶

func Errorf(t T, err error, msg string, args ...any) bool

Errorf is the same as Error, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Eventually ¶

func Eventually[C Conditioner](t T, condition C, timeout time.Duration, tick time.Duration, msgAndArgs ...any) bool

Eventually asserts that the given condition will be met before timeout, periodically checking the target function on each tick.

Eventually waits until the condition returns true, at most until timeout, or until the parent context of the test is cancelled.

If the condition takes longer than the timeout to complete, Eventually fails but waits for the current condition execution to finish before returning.

For long-running conditions to be interrupted early, check testing.T.Context which is cancelled on test failure.

Usage ¶

assertions.Eventually(t, func() bool { return true }, time.Second, 10*time.Millisecond)

Alternative condition signature ¶

The simplest form of condition is:

func() bool

To build more complex cases, a condition may also be defined as:

func(context.Context) error

It fails when an error has always been returned up to timeout (equivalent semantics to func() bool returns false), expressing "eventually returns no error (nil)".

It will be executed with the context of the assertion, which inherits the testing.T.Context and is cancelled on timeout.

The semantics of the three available async assertions read as follows.

• Eventually (func() bool) : "eventually returns true"

• Never (func() bool) : "never returns true"

• Consistently (func() bool): "always returns true"

• Eventually (func(ctx) error) : "eventually returns nil"

• Never (func(ctx) error) : not supported, use Consistently instead (avoids confusion with double negation)

• Consistently (func(ctx) error): "always returns nil"

Concurrency ¶

The condition function is always executed serially by a single goroutine. It is always executed at least once.

It may thus write to variables outside its scope without triggering race conditions.

A blocking condition will cause Eventually to hang until it returns.

Notice that time ticks may be skipped if the condition takes longer than the tick interval.

Attention point ¶

Time-based tests may be flaky in a resource-constrained environment such as a CI runner and may produce counter-intuitive results, such as ticks or timeouts not firing in time as expected.

To avoid flaky tests, always make sure that ticks and timeouts differ by at least an order of magnitude (tick << timeout).

Examples ¶

success:  func() bool { return true }, 100*time.Millisecond, 20*time.Millisecond
failure:  func() bool { return false }, 100*time.Millisecond, 20*time.Millisecond

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"
	"time"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestEventually(t *testing.T)
	success := assert.Eventually(t, func() bool {
		return true
	}, 100*time.Millisecond, 20*time.Millisecond)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

package main

import (
	"fmt"
	"sync/atomic"
	"testing"
	"time"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // normally provided by test

	// Simulate an async operation that completes after a short delay.
	var ready atomic.Bool
	go func() {
		time.Sleep(30 * time.Millisecond)
		ready.Store(true)
	}()

	result := assert.Eventually(t, ready.Load, 200*time.Millisecond, 10*time.Millisecond)

	fmt.Printf("eventually ready: %t", result)

}

Output:

eventually ready: true

package main

import (
	"context"
	"errors"
	"fmt"
	"sync/atomic"
	"testing"
	"time"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // normally provided by test

	// Simulate a service that becomes healthy after a few attempts.
	var attempts atomic.Int32
	healthCheck := func(_ context.Context) error {
		if attempts.Add(1) < 3 {
			return errors.New("service not ready")
		}

		return nil
	}

	result := assert.Eventually(t, healthCheck, 200*time.Millisecond, 10*time.Millisecond)

	fmt.Printf("eventually healthy: %t", result)

}

Output:

eventually healthy: true

func EventuallyWith ¶ added in v2.3.0

func EventuallyWith[C CollectibleConditioner](t T, condition C, timeout time.Duration, tick time.Duration, msgAndArgs ...any) bool

EventuallyWith asserts that the given condition will be met before the timeout, periodically checking the target function at each tick.

In contrast to Eventually, the condition function is supplied with a CollectT to accumulate errors from calling other assertions.

The condition is considered "met" if no errors are raised in a tick. The supplied CollectT collects all errors from one tick.

If the condition is not met before the timeout, the collected errors from the last tick are copied to t.

Calling [CollectT.FailNow] cancels the condition immediately and causes the assertion to fail.

Usage ¶

externalValue := false
go func() {
	time.Sleep(8*time.Second)
	externalValue = true
}()

assertions.EventuallyWith(t, func(c *assertions.CollectT) {
	// add assertions as needed; any assertion failure will fail the current tick
	assertions.True(c, externalValue, "expected 'externalValue' to be true")
},
10*time.Second,
1*time.Second,
"external state has not changed to 'true'; still false",
)

Concurrency ¶

The condition function is never executed in parallel: only one goroutine executes it. It may write to variables outside its scope without triggering race conditions.

Examples ¶

success: func(c *CollectT) { True(c,true) }, 100*time.Millisecond, 20*time.Millisecond
failure: func(c *CollectT) { False(c,true) }, 100*time.Millisecond, 20*time.Millisecond

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"
	"time"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestEventuallyWith(t *testing.T)
	success := assert.EventuallyWith(t, func(c *assert.CollectT) {
		assert.True(c, true)
	}, 100*time.Millisecond, 20*time.Millisecond)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func EventuallyWithf ¶ added in v2.3.0

func EventuallyWithf[C CollectibleConditioner](t T, condition C, timeout time.Duration, tick time.Duration, msg string, args ...any) bool

EventuallyWithf is the same as EventuallyWith, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Eventuallyf ¶

func Eventuallyf[C Conditioner](t T, condition C, timeout time.Duration, tick time.Duration, msg string, args ...any) bool

Eventuallyf is the same as Eventually, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Exactly ¶

func Exactly(t T, expected any, actual any, msgAndArgs ...any) bool

Exactly asserts that two objects are equal in value and type.

Usage ¶

assertions.Exactly(t, int32(123), int64(123))

Examples ¶

success: int32(123), int32(123)
failure: int32(123), int64(123)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestExactly(t *testing.T)
	success := assert.Exactly(t, int32(123), int32(123))
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Exactlyf ¶

func Exactlyf(t T, expected any, actual any, msg string, args ...any) bool

Exactlyf is the same as Exactly, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Fail ¶

func Fail(t T, failureMessage string, msgAndArgs ...any) bool

Fail reports a failure through.

Usage ¶

assertions.Fail(t, "failed")

Examples ¶

failure: "failed"

Upon failure, the test T is marked as failed and continues execution.

func FailNow ¶

func FailNow(t T, failureMessage string, msgAndArgs ...any) bool

FailNow fails test.

Usage ¶

assertions.FailNow(t, "failed")

Examples ¶

failure: "failed"

Upon failure, the test T is marked as failed and continues execution.

func FailNowf ¶

func FailNowf(t T, failureMessage string, msg string, args ...any) bool

FailNowf is the same as FailNow, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Failf ¶

func Failf(t T, failureMessage string, msg string, args ...any) bool

Failf is the same as Fail, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func False ¶

func False(t T, value bool, msgAndArgs ...any) bool

False asserts that the specified value is false.

Usage ¶

assertions.False(t, myBool)

Examples ¶

success: 1 == 0
failure: 1 == 1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestFalse(t *testing.T)
	success := assert.False(t, 1 == 0)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func FalseT ¶ added in v2.2.0

func FalseT[B Boolean](t T, value B, msgAndArgs ...any) bool

FalseT asserts that the specified value is false.

The type constraint Boolean accepts any type which underlying type is bool.

Usage ¶

type B bool
var b B = true

assertions.FalseT(t, b)

Examples ¶

success: 1 == 0
failure: 1 == 1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestFalseT(t *testing.T)
	success := assert.FalseT(t, 1 == 0)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func FalseTf ¶ added in v2.2.0

func FalseTf[B Boolean](t T, value B, msg string, args ...any) bool

FalseTf is the same as FalseT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Falsef ¶

func Falsef(t T, value bool, msg string, args ...any) bool

Falsef is the same as False, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func FileEmpty ¶ added in v2.1.0

func FileEmpty(t T, path string, msgAndArgs ...any) bool

FileEmpty checks whether a file exists in the given path and is empty. It fails if the file is not empty, if the path points to a directory or there is an error when trying to check the file.

Usage ¶

assertions.FileEmpty(t, "path/to/file")

Examples ¶

success: filepath.Join(testDataPath(),"empty_file")
failure: filepath.Join(testDataPath(),"existing_file")

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"path/filepath"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestFileEmpty(t *testing.T)
	success := assert.FileEmpty(t, filepath.Join(testDataPath(), "empty_file"))
	fmt.Printf("success: %t\n", success)

}

func testDataPath() string {
	return filepath.Join("..", "internal", "assertions", "testdata")
}

Output:

success: true

func FileEmptyf ¶ added in v2.1.0

func FileEmptyf(t T, path string, msg string, args ...any) bool

FileEmptyf is the same as FileEmpty, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func FileExists ¶

func FileExists(t T, path string, msgAndArgs ...any) bool

FileExists checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file.

Usage ¶

assertions.FileExists(t, "path/to/file")

Examples ¶

success: filepath.Join(testDataPath(),"existing_file")
failure: filepath.Join(testDataPath(),"non_existing_file")

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"path/filepath"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestFileExists(t *testing.T)
	success := assert.FileExists(t, filepath.Join(testDataPath(), "existing_file"))
	fmt.Printf("success: %t\n", success)

}

func testDataPath() string {
	return filepath.Join("..", "internal", "assertions", "testdata")
}

Output:

success: true

func FileExistsf ¶

func FileExistsf(t T, path string, msg string, args ...any) bool

FileExistsf is the same as FileExists, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func FileNotEmpty ¶ added in v2.1.0

func FileNotEmpty(t T, path string, msgAndArgs ...any) bool

FileNotEmpty checks whether a file exists in the given path and is not empty. It fails if the file is empty, if the path points to a directory or there is an error when trying to check the file.

Usage ¶

assertions.FileNotEmpty(t, "path/to/file")

Examples ¶

success: filepath.Join(testDataPath(),"existing_file")
failure: filepath.Join(testDataPath(),"empty_file")

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"path/filepath"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestFileNotEmpty(t *testing.T)
	success := assert.FileNotEmpty(t, filepath.Join(testDataPath(), "existing_file"))
	fmt.Printf("success: %t\n", success)

}

func testDataPath() string {
	return filepath.Join("..", "internal", "assertions", "testdata")
}

Output:

success: true

func FileNotEmptyf ¶ added in v2.1.0

func FileNotEmptyf(t T, path string, msg string, args ...any) bool

FileNotEmptyf is the same as FileNotEmpty, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func FileNotExists ¶ added in v2.2.0

func FileNotExists(t T, path string, msgAndArgs ...any) bool

FileNotExists checks whether a file does not exist in a given path. It fails if the path points to an existing _file_ only.

Usage ¶

assertions.FileNotExists(t, "path/to/file")

Examples ¶

success: filepath.Join(testDataPath(),"non_existing_file")
failure: filepath.Join(testDataPath(),"existing_file")

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"path/filepath"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestFileNotExists(t *testing.T)
	success := assert.FileNotExists(t, filepath.Join(testDataPath(), "non_existing_file"))
	fmt.Printf("success: %t\n", success)

}

func testDataPath() string {
	return filepath.Join("..", "internal", "assertions", "testdata")
}

Output:

success: true

func FileNotExistsf ¶ added in v2.2.0

func FileNotExistsf(t T, path string, msg string, args ...any) bool

FileNotExistsf is the same as FileNotExists, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Greater ¶

func Greater(t T, e1 any, e2 any, msgAndArgs ...any) bool

Greater asserts that the first element is strictly greater than the second.

Both elements must be of the same type in the reflect.Kind sense. To compare values that need a type conversion (e.g. float32 against float64), you need to convert types beforehand.

Usage ¶

assertions.Greater(t, 2, 1)
assertions.Greater(t, float64(2), float64(1))
assertions.Greater(t, "b", "a")

Examples ¶

success: 2, 1
failure: 1, 2

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestGreater(t *testing.T)
	success := assert.Greater(t, 2, 1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func GreaterOrEqual ¶

func GreaterOrEqual(t T, e1 any, e2 any, msgAndArgs ...any) bool

GreaterOrEqual asserts that the first element is greater than or equal to the second.

See also Greater.

Usage ¶

assertions.GreaterOrEqual(t, 2, 1)
assertions.GreaterOrEqual(t, 2, 2)
assertions.GreaterOrEqual(t, "b", "a")
assertions.GreaterOrEqual(t, "b", "b")

Examples ¶

success: 2, 1
failure: 1, 2

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestGreaterOrEqual(t *testing.T)
	success := assert.GreaterOrEqual(t, 2, 1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func GreaterOrEqualT ¶ added in v2.2.0

func GreaterOrEqualT[Orderable Ordered](t T, e1 Orderable, e2 Orderable, msgAndArgs ...any) bool

GreaterOrEqualT asserts that for two elements of the same type, the first element is greater than or equal to the second.

The Ordered type can be any of Go's cmp.Ordered (strings, numeric types), []byte (uses bytes.Compare) and time.Time (uses time.Time.Compare.

Notice that pointers are not Ordered, but uintptr are. So you can't call GreaterOrEqualT with *time.Time.

GreaterOrEqualT ensures type safety at build time. If you need to compare values with a dynamically assigned type, use GreaterOrEqual instead.

To compare values that need a type conversion (e.g. float32 against float64), you need to convert types beforehand.

Usage ¶

assertions.GreaterOrEqualT(t, 2, 1)
assertions.GreaterOrEqualT(t, 2, 2)
assertions.GreaterOrEqualT(t, "b", "a")
assertions.GreaterOrEqualT(t, "b", "b")

Examples ¶

success: 2, 1
failure: 1, 2

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestGreaterOrEqualT(t *testing.T)
	success := assert.GreaterOrEqualT(t, 2, 1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func GreaterOrEqualTf ¶ added in v2.2.0

func GreaterOrEqualTf[Orderable Ordered](t T, e1 Orderable, e2 Orderable, msg string, args ...any) bool

GreaterOrEqualTf is the same as GreaterOrEqualT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func GreaterOrEqualf ¶

func GreaterOrEqualf(t T, e1 any, e2 any, msg string, args ...any) bool

GreaterOrEqualf is the same as GreaterOrEqual, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func GreaterT ¶ added in v2.2.0

func GreaterT[Orderable Ordered](t T, e1 Orderable, e2 Orderable, msgAndArgs ...any) bool

GreaterT asserts that for two elements of the same type, the first element is strictly greater than the second.

The Ordered type can be any of Go's cmp.Ordered (strings, numeric types), []byte (uses bytes.Compare) and time.Time (uses time.Time.Compare.

Notice that pointers are not Ordered, but uintptr are. So you can't call GreaterT with *time.Time.

GreaterT ensures type safety at build time. If you need to compare values with a dynamically assigned type, use Greater instead.

To compare values that need a type conversion (e.g. float32 against float64), you need to convert types beforehand.

Usage ¶

assertions.GreaterT(t, 2, 1)
assertions.GreaterT(t, float64(2), float64(1))
assertions.GreaterT(t, "b", "a")
assertions.GreaterT(t, time.Date(2026,1,1,0,0,0,0,nil), time.Now())

Examples ¶

success: 2, 1
failure: 1, 2

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestGreaterT(t *testing.T)
	success := assert.GreaterT(t, 2, 1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func GreaterTf ¶ added in v2.2.0

func GreaterTf[Orderable Ordered](t T, e1 Orderable, e2 Orderable, msg string, args ...any) bool

GreaterTf is the same as GreaterT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Greaterf ¶

func Greaterf(t T, e1 any, e2 any, msg string, args ...any) bool

Greaterf is the same as Greater, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func HTTPBody ¶

func HTTPBody(handler http.HandlerFunc, method string, url string, values url.Values) string

HTTPBody is a helper that returns the HTTP body of the response. It returns the empty string if building a new request fails.

func HTTPBodyContains ¶

func HTTPBodyContains(t T, handler http.HandlerFunc, method string, url string, values url.Values, str any, msgAndArgs ...any) bool

HTTPBodyContains asserts that a specified handler returns a body that contains a string.

Returns whether the assertion was successful (true) or not (false).

Usage ¶

assertions.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")

Examples ¶

success: httpBody, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"
failure: httpBody, "GET", "/", url.Values{"name": []string{"Bob"}}, "Hello, World!"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"net/http"
	"net/url"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestHTTPBodyContains(t *testing.T)
	success := assert.HTTPBodyContains(t, httpBody, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!")
	fmt.Printf("success: %t\n", success)

}

func httpBody(w http.ResponseWriter, r *http.Request) {
	name := r.FormValue("name")
	_, _ = fmt.Fprintf(w, "Hello, %s!", name)
}

Output:

success: true

func HTTPBodyContainsf ¶

func HTTPBodyContainsf(t T, handler http.HandlerFunc, method string, url string, values url.Values, str any, msg string, args ...any) bool

HTTPBodyContainsf is the same as HTTPBodyContains, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func HTTPBodyNotContains ¶

func HTTPBodyNotContains(t T, handler http.HandlerFunc, method string, url string, values url.Values, str any, msgAndArgs ...any) bool

HTTPBodyNotContains asserts that a specified handler returns a body that does not contain a string.

Returns whether the assertion was successful (true) or not (false).

Usage ¶

assertions.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")

Examples ¶

success: httpBody, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, Bob!"
failure: httpBody, "GET", "/", url.Values{"name": []string{"Bob"}}, "Hello, Bob!"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"net/http"
	"net/url"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestHTTPBodyNotContains(t *testing.T)
	success := assert.HTTPBodyNotContains(t, httpBody, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, Bob!")
	fmt.Printf("success: %t\n", success)

}

func httpBody(w http.ResponseWriter, r *http.Request) {
	name := r.FormValue("name")
	_, _ = fmt.Fprintf(w, "Hello, %s!", name)
}

Output:

success: true

func HTTPBodyNotContainsf ¶

func HTTPBodyNotContainsf(t T, handler http.HandlerFunc, method string, url string, values url.Values, str any, msg string, args ...any) bool

HTTPBodyNotContainsf is the same as HTTPBodyNotContains, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func HTTPError ¶

func HTTPError(t T, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...any) bool

HTTPError asserts that a specified handler returns an error status code.

Returns whether the assertion was successful (true) or not (false).

Usage ¶

assertions.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}

Examples ¶

success: httpError, "GET", "/", nil
failure: httpOK, "GET", "/", nil

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"net/http"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestHTTPError(t *testing.T)
	success := assert.HTTPError(t, httpError, "GET", "/", nil)
	fmt.Printf("success: %t\n", success)

}

func httpError(w http.ResponseWriter, _ *http.Request) {
	w.WriteHeader(http.StatusInternalServerError)
}

Output:

success: true

func HTTPErrorf ¶

func HTTPErrorf(t T, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...any) bool

HTTPErrorf is the same as HTTPError, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func HTTPRedirect ¶

func HTTPRedirect(t T, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...any) bool

HTTPRedirect asserts that a specified handler returns a redirect status code.

Returns whether the assertion was successful (true) or not (false).

Usage ¶

assertions.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}

Examples ¶

success: httpRedirect, "GET", "/", nil
failure: httpError, "GET", "/", nil

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"net/http"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestHTTPRedirect(t *testing.T)
	success := assert.HTTPRedirect(t, httpRedirect, "GET", "/", nil)
	fmt.Printf("success: %t\n", success)

}

func httpRedirect(w http.ResponseWriter, _ *http.Request) {
	w.WriteHeader(http.StatusTemporaryRedirect)
}

Output:

success: true

func HTTPRedirectf ¶

func HTTPRedirectf(t T, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...any) bool

HTTPRedirectf is the same as HTTPRedirect, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func HTTPStatusCode ¶

func HTTPStatusCode(t T, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...any) bool

HTTPStatusCode asserts that a specified handler returns a specified status code.

Returns whether the assertion was successful (true) or not (false).

Usage ¶

assertions.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501)

Examples ¶

success: httpOK, "GET", "/", nil, http.StatusOK
failure: httpError, "GET", "/", nil, http.StatusOK

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"net/http"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestHTTPStatusCode(t *testing.T)
	success := assert.HTTPStatusCode(t, httpOK, "GET", "/", nil, http.StatusOK)
	fmt.Printf("success: %t\n", success)

}

func httpOK(w http.ResponseWriter, _ *http.Request) {
	w.WriteHeader(http.StatusOK)
}

Output:

success: true

func HTTPStatusCodef ¶

func HTTPStatusCodef(t T, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...any) bool

HTTPStatusCodef is the same as HTTPStatusCode, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func HTTPSuccess ¶

func HTTPSuccess(t T, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...any) bool

HTTPSuccess asserts that a specified handler returns a success status code.

Returns whether the assertion was successful (true) or not (false).

Usage ¶

assertions.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)

Examples ¶

success: httpOK, "GET", "/", nil
failure: httpError, "GET", "/", nil

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"net/http"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestHTTPSuccess(t *testing.T)
	success := assert.HTTPSuccess(t, httpOK, "GET", "/", nil)
	fmt.Printf("success: %t\n", success)

}

func httpOK(w http.ResponseWriter, _ *http.Request) {
	w.WriteHeader(http.StatusOK)
}

Output:

success: true

func HTTPSuccessf ¶

func HTTPSuccessf(t T, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...any) bool

HTTPSuccessf is the same as HTTPSuccess, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Implements ¶

func Implements(t T, interfaceObject any, object any, msgAndArgs ...any) bool

Implements asserts that an object is implemented by the specified interface.

Usage ¶

assertions.Implements(t, (*MyInterface)(nil), new(MyObject))

Examples ¶

success: ptr(dummyInterface), new(testing.T)
failure: (*error)(nil), new(testing.T)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestImplements(t *testing.T)
	success := assert.Implements(t, ptr(dummyInterface), new(testing.T))
	fmt.Printf("success: %t\n", success)

}

//nolint:gochecknoglobals // this is on purpose to share a common pointer when testing
var (
	staticVar = "static string"

	dummyInterface assert.T
)

func ptr[T any](value T) *T {
	p := value

	return &p
}

Output:

success: true

func Implementsf ¶

func Implementsf(t T, interfaceObject any, object any, msg string, args ...any) bool

Implementsf is the same as Implements, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func InDelta ¶

func InDelta(t T, expected any, actual any, delta float64, msgAndArgs ...any) bool

InDelta asserts that the two numerals are within delta of each other.

Delta must be greater than or equal to zero.

Expected and actual values should convert to float64. To compare large integers that can't be represented accurately as float64 (e.g. uint64), prefer InDeltaT to preserve the original type.

Behavior with IEEE floating point arithmetic ¶

• expected NaN is matched only by a NaN, e.g. this works: InDeltaT(math.Sqrt(-1), math.Sqrt(-1), 0.0)
• expected +Inf is matched only by a +Inf
• expected -Inf is matched only by a -Inf

Usage ¶

assertions.InDelta(t, math.Pi, 22/7.0, 0.01)

Examples ¶

success: 1.0, 1.01, 0.02
failure: 1.0, 1.1, 0.05

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestInDelta(t *testing.T)
	success := assert.InDelta(t, 1.0, 1.01, 0.02)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func InDeltaMapValues ¶

func InDeltaMapValues(t T, expected any, actual any, delta float64, msgAndArgs ...any) bool

InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.

See InDelta.

Usage ¶

assertions.InDeltaMapValues(t, map[string]float64{"a": 1.0}, map[string]float64{"a": 1.01}, 0.02)

Examples ¶

success: map[string]float64{"a": 1.0}, map[string]float64{"a": 1.01}, 0.02
failure: map[string]float64{"a": 1.0}, map[string]float64{"a": 1.1}, 0.05

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestInDeltaMapValues(t *testing.T)
	success := assert.InDeltaMapValues(t, map[string]float64{"a": 1.0}, map[string]float64{"a": 1.01}, 0.02)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func InDeltaMapValuesf ¶

func InDeltaMapValuesf(t T, expected any, actual any, delta float64, msg string, args ...any) bool

InDeltaMapValuesf is the same as InDeltaMapValues, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func InDeltaSlice ¶

func InDeltaSlice(t T, expected any, actual any, delta float64, msgAndArgs ...any) bool

InDeltaSlice is the same as InDelta, except it compares two slices.

See InDelta.

Usage ¶

assertions.InDeltaSlice(t, []float64{1.0, 2.0}, []float64{1.01, 2.01}, 0.02)

Examples ¶

success: []float64{1.0, 2.0}, []float64{1.01, 2.01}, 0.02
failure: []float64{1.0, 2.0}, []float64{1.1, 2.1}, 0.05

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestInDeltaSlice(t *testing.T)
	success := assert.InDeltaSlice(t, []float64{1.0, 2.0}, []float64{1.01, 2.01}, 0.02)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func InDeltaSlicef ¶

func InDeltaSlicef(t T, expected any, actual any, delta float64, msg string, args ...any) bool

InDeltaSlicef is the same as InDeltaSlice, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func InDeltaT ¶ added in v2.2.0

func InDeltaT[Number Measurable](t T, expected Number, actual Number, delta Number, msgAndArgs ...any) bool

InDeltaT asserts that the two numerals of the same type numerical type are within delta of each other.

InDeltaT accepts any go numeric type, including integer types.

The main difference with InDelta is that the delta is expressed with the same type as the values, not necessarily a float64.

Delta must be greater than or equal to zero.

Behavior with IEEE floating point arithmetic ¶

• expected NaN is matched only by a NaN, e.g. this works: InDeltaT(math.NaN(), math.Sqrt(-1), 0.0)
• expected +Inf is matched only by a +Inf
• expected -Inf is matched only by a -Inf

Usage ¶

assertions.InDeltaT(t, math.Pi, 22/7.0, 0.01)

Examples ¶

success: 1.0, 1.01, 0.02
failure: 1.0, 1.1, 0.05

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestInDeltaT(t *testing.T)
	success := assert.InDeltaT(t, 1.0, 1.01, 0.02)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func InDeltaTf ¶ added in v2.2.0

func InDeltaTf[Number Measurable](t T, expected Number, actual Number, delta Number, msg string, args ...any) bool

InDeltaTf is the same as InDeltaT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func InDeltaf ¶

func InDeltaf(t T, expected any, actual any, delta float64, msg string, args ...any) bool

InDeltaf is the same as InDelta, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func InEpsilon ¶

func InEpsilon(t T, expected any, actual any, epsilon float64, msgAndArgs ...any) bool

InEpsilon asserts that expected and actual have a relative error less than epsilon.

Behavior with IEEE floating point arithmetic ¶

• expected NaN is matched only by a NaN, e.g. this works: InDeltaT(math.NaN(), math.Sqrt(-1), 0.0)
• expected +Inf is matched only by a +Inf
• expected -Inf is matched only by a -Inf

Edge case: for very large integers that do not convert accurately to a float64 (e.g. uint64), prefer InDeltaT.

Formula:

• If expected == 0: fail if |actual - expected| > epsilon
• If expected != 0: fail if |actual - expected| > epsilon * |expected|

This allows InEpsilonT to work naturally across the full numeric range including zero.

Usage ¶

assertions.InEpsilon(t, 100.0, 101.0, 0.02)

Examples ¶

success: 100.0, 101.0, 0.02
failure: 100.0, 110.0, 0.05

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestInEpsilon(t *testing.T)
	success := assert.InEpsilon(t, 100.0, 101.0, 0.02)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func InEpsilonSlice ¶

func InEpsilonSlice(t T, expected any, actual any, epsilon float64, msgAndArgs ...any) bool

InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.

See InEpsilon.

Usage ¶

assertions.InEpsilonSlice(t, []float64{100.0, 200.0}, []float64{101.0, 202.0}, 0.02)

Examples ¶

success: []float64{100.0, 200.0}, []float64{101.0, 202.0}, 0.02
failure: []float64{100.0, 200.0}, []float64{110.0, 220.0}, 0.05

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestInEpsilonSlice(t *testing.T)
	success := assert.InEpsilonSlice(t, []float64{100.0, 200.0}, []float64{101.0, 202.0}, 0.02)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func InEpsilonSlicef ¶

func InEpsilonSlicef(t T, expected any, actual any, epsilon float64, msg string, args ...any) bool

InEpsilonSlicef is the same as InEpsilonSlice, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func InEpsilonT ¶ added in v2.2.0

func InEpsilonT[Number Measurable](t T, expected Number, actual Number, epsilon float64, msgAndArgs ...any) bool

InEpsilonT asserts that expected and actual have a relative error less than epsilon.

When expected is zero, epsilon is interpreted as an absolute error threshold, since relative error is mathematically undefined for zero values.

Unlike InDeltaT, which preserves the original type, InEpsilonT converts the expected and actual numbers to float64, since the relative error doesn't make sense as an integer.

Behavior with IEEE floating point arithmetic ¶

• expected NaN is matched only by a NaN, e.g. this works: InDeltaT(math.NaN(), math.Sqrt(-1), 0.0)
• expected +Inf is matched only by a +Inf
• expected -Inf is matched only by a -Inf

Edge case: for very large integers that do not convert accurately to a float64 (e.g. uint64), prefer InDeltaT.

Formula:

• If expected == 0: fail if |actual - expected| > epsilon
• If expected != 0: fail if |actual - expected| > epsilon * |expected|

This allows InEpsilonT to work naturally across the full numeric range including zero.

Usage ¶

assertions.InEpsilon(t, 100.0, 101.0, 0.02)

Examples ¶

success: 100.0, 101.0, 0.02
failure: 100.0, 110.0, 0.05

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestInEpsilonT(t *testing.T)
	success := assert.InEpsilonT(t, 100.0, 101.0, 0.02)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func InEpsilonTf ¶ added in v2.2.0

func InEpsilonTf[Number Measurable](t T, expected Number, actual Number, epsilon float64, msg string, args ...any) bool

InEpsilonTf is the same as InEpsilonT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func InEpsilonf ¶

func InEpsilonf(t T, expected any, actual any, epsilon float64, msg string, args ...any) bool

InEpsilonf is the same as InEpsilon, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsDecreasing ¶

func IsDecreasing(t T, collection any, msgAndArgs ...any) bool

IsDecreasing asserts that the collection is strictly decreasing.

Usage ¶

assertions.IsDecreasing(t, []int{2, 1, 0})
assertions.IsDecreasing(t, []float{2, 1})
assertions.IsDecreasing(t, []string{"b", "a"})

Examples ¶

success: []int{3, 2, 1}
failure: []int{1, 2, 3}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsDecreasing(t *testing.T)
	success := assert.IsDecreasing(t, []int{3, 2, 1})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsDecreasingT ¶ added in v2.2.0

func IsDecreasingT[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msgAndArgs ...any) bool

IsDecreasingT asserts that a slice of Ordered is strictly decreasing.

Usage ¶

assertions.IsDecreasingT(t, []int{2, 1, 0})
assertions.IsDecreasingT(t, []float{2, 1})
assertions.IsDecreasingT(t, []string{"b", "a"})

Examples ¶

success: []int{3, 2, 1}
failure: []int{1, 2, 3}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsDecreasingT(t *testing.T)
	success := assert.IsDecreasingT(t, []int{3, 2, 1})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsDecreasingTf ¶ added in v2.2.0

func IsDecreasingTf[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msg string, args ...any) bool

IsDecreasingTf is the same as IsDecreasingT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsDecreasingf ¶

func IsDecreasingf(t T, collection any, msg string, args ...any) bool

IsDecreasingf is the same as IsDecreasing, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsIncreasing ¶

func IsIncreasing(t T, collection any, msgAndArgs ...any) bool

IsIncreasing asserts that the collection is strictly increasing.

Usage ¶

assertions.IsIncreasing(t, []int{1, 2, 3})
assertions.IsIncreasing(t, []float{1, 2})
assertions.IsIncreasing(t, []string{"a", "b"})

Examples ¶

success: []int{1, 2, 3}
failure: []int{1, 1, 2}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsIncreasing(t *testing.T)
	success := assert.IsIncreasing(t, []int{1, 2, 3})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsIncreasingT ¶ added in v2.2.0

func IsIncreasingT[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msgAndArgs ...any) bool

IsIncreasingT asserts that a slice of Ordered is strictly increasing.

Usage ¶

assertions.IsIncreasingT(t, []int{1, 2, 3})
assertions.IsIncreasingT(t, []float{1, 2})
assertions.IsIncreasingT(t, []string{"a", "b"})

Examples ¶

success: []int{1, 2, 3}
failure: []int{1, 1, 2}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsIncreasingT(t *testing.T)
	success := assert.IsIncreasingT(t, []int{1, 2, 3})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsIncreasingTf ¶ added in v2.2.0

func IsIncreasingTf[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msg string, args ...any) bool

IsIncreasingTf is the same as IsIncreasingT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsIncreasingf ¶

func IsIncreasingf(t T, collection any, msg string, args ...any) bool

IsIncreasingf is the same as IsIncreasing, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsNonDecreasing ¶

func IsNonDecreasing(t T, collection any, msgAndArgs ...any) bool

IsNonDecreasing asserts that the collection is not strictly decreasing.

Usage ¶

assertions.IsNonDecreasing(t, []int{1, 1, 2})
assertions.IsNonDecreasing(t, []float{1, 2})
assertions.IsNonDecreasing(t, []string{"a", "b"})

Examples ¶

success: []int{1, 1, 2}
failure: []int{2, 1, 0}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsNonDecreasing(t *testing.T)
	success := assert.IsNonDecreasing(t, []int{1, 1, 2})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsNonDecreasingT ¶ added in v2.2.0

func IsNonDecreasingT[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msgAndArgs ...any) bool

IsNonDecreasingT asserts that a slice of Ordered is not decreasing.

Usage ¶

assertions.IsNonDecreasingT(t, []int{1, 1, 2})
assertions.IsNonDecreasingT(t, []float{1, 2})
assertions.IsNonDecreasingT(t, []string{"a", "b"})

Examples ¶

success: []int{1, 1, 2}
failure: []int{2, 1, 0}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsNonDecreasingT(t *testing.T)
	success := assert.IsNonDecreasingT(t, []int{1, 1, 2})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsNonDecreasingTf ¶ added in v2.2.0

func IsNonDecreasingTf[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msg string, args ...any) bool

IsNonDecreasingTf is the same as IsNonDecreasingT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsNonDecreasingf ¶

func IsNonDecreasingf(t T, collection any, msg string, args ...any) bool

IsNonDecreasingf is the same as IsNonDecreasing, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsNonIncreasing ¶

func IsNonIncreasing(t T, collection any, msgAndArgs ...any) bool

IsNonIncreasing asserts that the collection is not increasing.

Usage ¶

assertions.IsNonIncreasing(t, []int{2, 1, 1})
assertions.IsNonIncreasing(t, []float{2, 1})
assertions.IsNonIncreasing(t, []string{"b", "a"})

Examples ¶

success: []int{2, 1, 1}
failure: []int{1, 2, 3}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsNonIncreasing(t *testing.T)
	success := assert.IsNonIncreasing(t, []int{2, 1, 1})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsNonIncreasingT ¶ added in v2.2.0

func IsNonIncreasingT[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msgAndArgs ...any) bool

IsNonIncreasingT asserts that a slice of Ordered is NOT strictly increasing.

Usage ¶

assertions.IsNonIncreasing(t, []int{2, 1, 1})
assertions.IsNonIncreasing(t, []float{2, 1})
assertions.IsNonIncreasing(t, []string{"b", "a"})

Examples ¶

success: []int{2, 1, 1}
failure: []int{1, 2, 3}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsNonIncreasingT(t *testing.T)
	success := assert.IsNonIncreasingT(t, []int{2, 1, 1})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsNonIncreasingTf ¶ added in v2.2.0

func IsNonIncreasingTf[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msg string, args ...any) bool

IsNonIncreasingTf is the same as IsNonIncreasingT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsNonIncreasingf ¶

func IsNonIncreasingf(t T, collection any, msg string, args ...any) bool

IsNonIncreasingf is the same as IsNonIncreasing, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsNotOfTypeT ¶ added in v2.2.0

func IsNotOfTypeT[EType any](t T, object any, msgAndArgs ...any) bool

IsNotOfTypeT asserts that an object is not of a given type.

Usage ¶

assertions.IsOfType[MyType](t,myVar)

Examples ¶

success: 123.123
failure: myType(123.123)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsNotOfTypeT(t *testing.T)
	success := assert.IsNotOfTypeT[myType](t, 123.123)
	fmt.Printf("success: %t\n", success)

}

type myType float64

Output:

success: true

func IsNotOfTypeTf ¶ added in v2.2.0

func IsNotOfTypeTf[EType any](t T, object any, msg string, args ...any) bool

IsNotOfTypeTf is the same as IsNotOfTypeT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsNotType ¶

func IsNotType(t T, theType any, object any, msgAndArgs ...any) bool

IsNotType asserts that the specified objects are not of the same type.

Usage ¶

assertions.IsNotType(t, &NotMyStruct{}, &MyStruct{})

Examples ¶

success: int32(123), int64(456)
failure: 123, 456

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsNotType(t *testing.T)
	success := assert.IsNotType(t, int32(123), int64(456))
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsNotTypef ¶

func IsNotTypef(t T, theType any, object any, msg string, args ...any) bool

IsNotTypef is the same as IsNotType, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsOfTypeT ¶ added in v2.2.0

func IsOfTypeT[EType any](t T, object any, msgAndArgs ...any) bool

IsOfTypeT asserts that an object is of a given type.

Usage ¶

assertions.IsOfTypeT[MyType](t,myVar)

Examples ¶

success: myType(123.123)
failure: 123.123

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsOfTypeT(t *testing.T)
	success := assert.IsOfTypeT[myType](t, myType(123.123))
	fmt.Printf("success: %t\n", success)

}

type myType float64

Output:

success: true

func IsOfTypeTf ¶ added in v2.2.0

func IsOfTypeTf[EType any](t T, object any, msg string, args ...any) bool

IsOfTypeTf is the same as IsOfTypeT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func IsType ¶

func IsType(t T, expectedType any, object any, msgAndArgs ...any) bool

IsType asserts that the specified objects are of the same type.

Usage ¶

assertions.IsType(t, &MyStruct{}, &MyStruct{})

Examples ¶

success: 123, 456
failure: int32(123), int64(456)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestIsType(t *testing.T)
	success := assert.IsType(t, 123, 456)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func IsTypef ¶

func IsTypef(t T, expectedType any, object any, msg string, args ...any) bool

IsTypef is the same as IsType, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func JSONEq ¶

func JSONEq(t T, expected string, actual string, msgAndArgs ...any) bool

JSONEq asserts that two JSON strings are semantically equivalent.

Expected and actual must be valid JSON.

Usage ¶

assertions.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)

Examples ¶

success: `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`
failure: `{"hello": "world", "foo": "bar"}`, `[{"foo": "bar"}, {"hello": "world"}]`

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestJSONEq(t *testing.T)
	success := assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func JSONEqBytes ¶ added in v2.0.2

func JSONEqBytes(t T, expected []byte, actual []byte, msgAndArgs ...any) bool

JSONEqBytes asserts that two JSON slices of bytes are semantically equivalent.

Expected and actual must be valid JSON.

Usage ¶

assertions.JSONEqBytes(t, []byte(`{"hello": "world", "foo": "bar"}`), []byte(`{"foo": "bar", "hello": "world"}`))

Examples ¶

success: []byte(`{"hello": "world", "foo": "bar"}`), []byte(`{"foo": "bar", "hello": "world"}`)
failure: []byte(`{"hello": "world", "foo": "bar"}`), []byte(`[{"foo": "bar"}, {"hello": "world"}]`)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestJSONEqBytes(t *testing.T)
	success := assert.JSONEqBytes(t, []byte(`{"hello": "world", "foo": "bar"}`), []byte(`{"foo": "bar", "hello": "world"}`))
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func JSONEqBytesf ¶ added in v2.0.2

func JSONEqBytesf(t T, expected []byte, actual []byte, msg string, args ...any) bool

JSONEqBytesf is the same as JSONEqBytes, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func JSONEqT ¶ added in v2.2.0

func JSONEqT[EDoc, ADoc Text](t T, expected EDoc, actual ADoc, msgAndArgs ...any) bool

JSONEqT asserts that two JSON documents are semantically equivalent.

The expected and actual arguments may be string or []byte. They do not need to be of the same type.

Expected and actual must be valid JSON.

Usage ¶

assertions.JSONEqT(t, `{"hello": "world", "foo": "bar"}`, []byte(`{"foo": "bar", "hello": "world"}`))

Examples ¶

success: `{"hello": "world", "foo": "bar"}`, []byte(`{"foo": "bar", "hello": "world"}`)
failure: `{"hello": "world", "foo": "bar"}`, `[{"foo": "bar"}, {"hello": "world"}]`

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestJSONEqT(t *testing.T)
	success := assert.JSONEqT(t, `{"hello": "world", "foo": "bar"}`, []byte(`{"foo": "bar", "hello": "world"}`))
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func JSONEqTf ¶ added in v2.2.0

func JSONEqTf[EDoc, ADoc Text](t T, expected EDoc, actual ADoc, msg string, args ...any) bool

JSONEqTf is the same as JSONEqT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func JSONEqf ¶

func JSONEqf(t T, expected string, actual string, msg string, args ...any) bool

JSONEqf is the same as JSONEq, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func JSONMarshalAsT ¶ added in v2.3.0

func JSONMarshalAsT[EDoc Text](t T, expected EDoc, object any, msgAndArgs ...any) bool

JSONMarshalAsT wraps JSONEq after [json.Marshal].

The input JSON may be a string or []byte.

It fails if the marshaling returns an error or if the expected JSON bytes differ semantically from the expected ones.

Usage ¶

actual := struct {
	A int `json:"a"`
}{
	A: 10,
}

assertions.JSONUnmarshalAsT(t,expected, `{"a": 10}`)

Examples ¶

success: []byte(`{"A": "a"}`), dummyStruct{A: "a"}
failure: `[{"foo": "bar"}, {"hello": "world"}]`, 1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestJSONMarshalAsT(t *testing.T)
	success := assert.JSONMarshalAsT(t, []byte(`{"A": "a"}`), dummyStruct{A: "a"})
	fmt.Printf("success: %t\n", success)

}

type dummyStruct struct {
	A string
	b int
}

Output:

success: true

func JSONMarshalAsTf ¶ added in v2.3.0

func JSONMarshalAsTf[EDoc Text](t T, expected EDoc, object any, msg string, args ...any) bool

JSONMarshalAsTf is the same as JSONMarshalAsT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func JSONUnmarshalAsT ¶ added in v2.3.0

func JSONUnmarshalAsT[Object any, ADoc Text](t T, expected Object, jazon ADoc, msgAndArgs ...any) bool

JSONUnmarshalAsT wraps Equal after [json.Unmarshal].

The input JSON may be a string or []byte.

It fails if the unmarshaling returns an error or if the resulting object is not equal to the expected one.

Be careful not to wrap the expected object into an "any" interface if this is not what you expected: the unmarshaling would take this type to unmarshal as a map[string]any.

Usage ¶

expected := struct {
	A int `json:"a"`
}{
	A: 10,
}

assertions.JSONUnmarshalAsT(t,expected, `{"a": 10}`)

Examples ¶

success: dummyStruct{A: "a"} , []byte(`{"A": "a"}`)
failure: 1, `[{"foo": "bar"}, {"hello": "world"}]`

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestJSONUnmarshalAsT(t *testing.T)
	success := assert.JSONUnmarshalAsT(t, dummyStruct{A: "a"}, []byte(`{"A": "a"}`))
	fmt.Printf("success: %t\n", success)

}

type dummyStruct struct {
	A string
	b int
}

Output:

success: true

func JSONUnmarshalAsTf ¶ added in v2.3.0

func JSONUnmarshalAsTf[Object any, ADoc Text](t T, expected Object, jazon ADoc, msg string, args ...any) bool

JSONUnmarshalAsTf is the same as JSONUnmarshalAsT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Kind ¶ added in v2.2.0

func Kind(t T, expectedKind reflect.Kind, object any, msgAndArgs ...any) bool

Kind asserts that the reflect.Kind of a given object matches the expected reflect.Kind.

Kind reflects the concrete value stored in the object. The nil value (or interface with nil value) are comparable to reflect.Invalid. See also reflect.Value.Kind.

Usage ¶

assertions.Kind(t, reflect.String, "Hello World")

Examples ¶

success: reflect.String, "hello"
failure: reflect.String, 0

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"reflect"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestKind(t *testing.T)
	success := assert.Kind(t, reflect.String, "hello")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Kindf ¶ added in v2.2.0

func Kindf(t T, expectedKind reflect.Kind, object any, msg string, args ...any) bool

Kindf is the same as Kind, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Len ¶

func Len(t T, object any, length int, msgAndArgs ...any) bool

Len asserts that the specified object has specific length.

Len also fails if the object has a type that len() does not accept.

The asserted object can be a string, a slice, a map, an array, pointer to array or a channel.

Usage ¶

assertions.Len(t, mySlice, 3)
assertions.Len(t, myString, 4)
assertions.Len(t, myMap, 5)

Examples ¶

success: []string{"A","B"}, 2
failure: []string{"A","B"}, 1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestLen(t *testing.T)
	success := assert.Len(t, []string{"A", "B"}, 2)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Lenf ¶

func Lenf(t T, object any, length int, msg string, args ...any) bool

Lenf is the same as Len, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Less ¶

func Less(t T, e1 any, e2 any, msgAndArgs ...any) bool

Less asserts that the first element is strictly less than the second.

Both elements must be of the same type in the reflect.Kind sense. To compare values that need a type conversion (e.g. float32 against float64), you need to convert types beforehand.

Usage ¶

assertions.Less(t, 1, 2)
assertions.Less(t, float64(1), float64(2))
assertions.Less(t, "a", "b")

Examples ¶

success: 1, 2
failure: 2, 1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestLess(t *testing.T)
	success := assert.Less(t, 1, 2)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func LessOrEqual ¶

func LessOrEqual(t T, e1 any, e2 any, msgAndArgs ...any) bool

LessOrEqual asserts that the first element is less than or equal to the second.

Usage ¶

assertions.LessOrEqual(t, 1, 2)
assertions.LessOrEqual(t, 2, 2)
assertions.LessOrEqual(t, "a", "b")
assertions.LessOrEqual(t, "b", "b")

Examples ¶

success: 1, 2
failure: 2, 1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestLessOrEqual(t *testing.T)
	success := assert.LessOrEqual(t, 1, 2)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func LessOrEqualT ¶ added in v2.2.0

func LessOrEqualT[Orderable Ordered](t T, e1 Orderable, e2 Orderable, msgAndArgs ...any) bool

LessOrEqualT asserts that for two elements of the same type, the first element is less than or equal to the second.

The Ordered type can be any of Go's cmp.Ordered (strings, numeric types), []byte (uses bytes.Compare) and time.Time (uses time.Time.Compare.

Notice that pointers are not Ordered, but uintptr are. So you can't call LessOrEqualT with *time.Time.

LessOrEqualT ensures type safety at build time. If you need to compare values with a dynamically assigned type, use LessOrEqual instead.

To compare values that need a type conversion (e.g. float32 against float64), you should use LessOrEqual instead.

Usage ¶

assertions.LessOrEqualT(t, 1, 2)
assertions.LessOrEqualT(t, 2, 2)
assertions.LessOrEqualT(t, "a", "b")
assertions.LessOrEqualT(t, "b", "b")

Examples ¶

success: 1, 2
failure: 2, 1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestLessOrEqualT(t *testing.T)
	success := assert.LessOrEqualT(t, 1, 2)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func LessOrEqualTf ¶ added in v2.2.0

func LessOrEqualTf[Orderable Ordered](t T, e1 Orderable, e2 Orderable, msg string, args ...any) bool

LessOrEqualTf is the same as LessOrEqualT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func LessOrEqualf ¶

func LessOrEqualf(t T, e1 any, e2 any, msg string, args ...any) bool

LessOrEqualf is the same as LessOrEqual, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func LessT ¶ added in v2.2.0

func LessT[Orderable Ordered](t T, e1 Orderable, e2 Orderable, msgAndArgs ...any) bool

LessT asserts that for two elements of the same type, the first element is strictly less than the second.

The Ordered type can be any of Go's cmp.Ordered (strings, numeric types), []byte (uses bytes.Compare) and time.Time (uses time.Time.Compare.

Notice that pointers are not Ordered, but uintptr are. So you can't call LessT with *time.Time.

LessT ensures type safety at build time. If you need to compare values with a dynamically assigned type, use Less instead.

To compare values that need a type conversion (e.g. float32 against float64), you need to convert types beforehand.

Usage ¶

assertions.LessT(t, 1, 2)
assertions.LessT(t, float64(1), float64(2))
assertions.LessT(t, "a", "b")

Examples ¶

success: 1, 2
failure: 2, 1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestLessT(t *testing.T)
	success := assert.LessT(t, 1, 2)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func LessTf ¶ added in v2.2.0

func LessTf[Orderable Ordered](t T, e1 Orderable, e2 Orderable, msg string, args ...any) bool

LessTf is the same as LessT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Lessf ¶

func Lessf(t T, e1 any, e2 any, msg string, args ...any) bool

Lessf is the same as Less, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func MapContainsT ¶ added in v2.2.0

func MapContainsT[Map ~map[K]V, K comparable, V any](t T, m Map, key K, msgAndArgs ...any) bool

MapContainsT asserts that the specified map contains a key.

Go native comparable types are explained there: comparable-types.

Usage ¶

assertions.MapContainsT(t, map[string]string{"Hello": "x","World": "y"}, "World")

Examples ¶

success: map[string]string{"A": "B"}, "A"
failure: map[string]string{"A": "B"}, "C"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestMapContainsT(t *testing.T)
	success := assert.MapContainsT(t, map[string]string{"A": "B"}, "A")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func MapContainsTf ¶ added in v2.2.0

func MapContainsTf[Map ~map[K]V, K comparable, V any](t T, m Map, key K, msg string, args ...any) bool

MapContainsTf is the same as MapContainsT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func MapNotContainsT ¶ added in v2.2.0

func MapNotContainsT[Map ~map[K]V, K comparable, V any](t T, m Map, key K, msgAndArgs ...any) bool

MapNotContainsT asserts that the specified map does not contain a key.

Usage ¶

assertions.MapNotContainsT(t, map[string]string{"Hello": "x","World": "y"}, "hi")

Examples ¶

success: map[string]string{"A": "B"}, "C"
failure: map[string]string{"A": "B"}, "A"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestMapNotContainsT(t *testing.T)
	success := assert.MapNotContainsT(t, map[string]string{"A": "B"}, "C")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func MapNotContainsTf ¶ added in v2.2.0

func MapNotContainsTf[Map ~map[K]V, K comparable, V any](t T, m Map, key K, msg string, args ...any) bool

MapNotContainsTf is the same as MapNotContainsT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Negative ¶

func Negative(t T, e any, msgAndArgs ...any) bool

Negative asserts that the specified element is strictly negative.

Usage ¶

assertions.Negative(t, -1)
assertions.Negative(t, -1.23)

Examples ¶

success: -1
failure: 1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNegative(t *testing.T)
	success := assert.Negative(t, -1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NegativeT ¶ added in v2.2.0

func NegativeT[SignedNumber SignedNumeric](t T, e SignedNumber, msgAndArgs ...any) bool

NegativeT asserts that the specified element of a signed numeric type is strictly negative.

Usage ¶

assertions.NegativeT(t, -1)
assertions.NegativeT(t, -1.23)

Examples ¶

success: -1
failure: 1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNegativeT(t *testing.T)
	success := assert.NegativeT(t, -1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NegativeTf ¶ added in v2.2.0

func NegativeTf[SignedNumber SignedNumeric](t T, e SignedNumber, msg string, args ...any) bool

NegativeTf is the same as NegativeT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Negativef ¶

func Negativef(t T, e any, msg string, args ...any) bool

Negativef is the same as Negative, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Never ¶

func Never(t T, condition func() bool, timeout time.Duration, tick time.Duration, msgAndArgs ...any) bool

Never asserts that the given condition is never satisfied until timeout, periodically checking the target function at each tick.

Never is the opposite of Eventually ("at least once"). It succeeds if the timeout is reached without the condition ever returning true.

If the parent context is cancelled before the timeout, Never fails.

Usage ¶

assertions.Never(t, func() bool { return false }, time.Second, 10*time.Millisecond)

See also Eventually for details about using context and concurrency.

Alternative condition signature ¶

The simplest form of condition is:

func() bool

Use Consistently instead if you want to use a condition returning an error.

Concurrency ¶

See Eventually.

Attention point ¶

See Eventually.

Examples ¶

success:  func() bool { return false }, 100*time.Millisecond, 20*time.Millisecond
failure:  func() bool { return true }, 100*time.Millisecond, 20*time.Millisecond

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"
	"time"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNever(t *testing.T)
	success := assert.Never(t, func() bool {
		return false
	}, 100*time.Millisecond, 20*time.Millisecond)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

package main

import (
	"fmt"
	"testing"
	"time"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // normally provided by test

	// A channel that should remain empty during the test.
	events := make(chan struct{}, 1)

	result := assert.Never(t, func() bool {
		select {
		case <-events:
			return true // event received = condition becomes true = Never fails
		default:
			return false
		}
	}, 100*time.Millisecond, 10*time.Millisecond)

	fmt.Printf("never received: %t", result)

}

Output:

never received: true

func Neverf ¶

func Neverf(t T, condition func() bool, timeout time.Duration, tick time.Duration, msg string, args ...any) bool

Neverf is the same as Never, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Nil ¶

func Nil(t T, object any, msgAndArgs ...any) bool

Nil asserts that the specified object is nil.

Usage ¶

assertions.Nil(t, err)

Examples ¶

success: nil
failure: "not nil"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNil(t *testing.T)
	success := assert.Nil(t, nil)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func Nilf ¶

func Nilf(t T, object any, msg string, args ...any) bool

Nilf is the same as Nil, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NoError ¶

func NoError(t T, err error, msgAndArgs ...any) bool

NoError asserts that a function returned a nil error (i.e. no error).

Usage ¶

actualObj, err := SomeFunction()
if assert.NoError(t, err) {
	assertions.Equal(t, expectedObj, actualObj)
}

Examples ¶

success: nil
failure: ErrTest

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNoError(t *testing.T)
	success := assert.NoError(t, nil)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NoErrorf ¶

func NoErrorf(t T, err error, msg string, args ...any) bool

NoErrorf is the same as NoError, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NoFileDescriptorLeak ¶ added in v2.4.0

func NoFileDescriptorLeak(t T, tested func(), msgAndArgs ...any) bool

NoFileDescriptorLeak ensures that no file descriptor leaks from inside the tested function.

This assertion works on Linux only (via /proc/self/fd). On other platforms, the test is skipped.

NOTE: this assertion is not compatible with parallel tests. File descriptors are a process-wide resource; concurrent tests opening files would cause false positives.

Sockets, pipes, and anonymous inodes are filtered out by default, as these are typically managed by the Go runtime.

Concurrency ¶

NoFileDescriptorLeak is not compatible with parallel tests. File descriptors are a process-wide resource; any concurrent I/O from other goroutines may cause false positives.

Calls to NoFileDescriptorLeak are serialized with a mutex to prevent multiple leak checks from interfering with each other.

Usage ¶

NoFileDescriptorLeak(t, func() {
	// code that should not leak file descriptors
})

Examples ¶

success: func() {}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"runtime"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	if runtime.GOOS != "linux" {
		// This example is only runnable on linux. On other platforms, the assertion skips the test.
		// We force the expected output below, so that tests don't fail on other platforms.
		fmt.Println("success: true")

		return
	}

	t := new(testing.T) // should come from testing, e.g. func TestNoFileDescriptorLeak(t *testing.T)
	success := assert.NoFileDescriptorLeak(t, func() {
	})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NoFileDescriptorLeakf ¶ added in v2.4.0

func NoFileDescriptorLeakf(t T, tested func(), msg string, args ...any) bool

NoFileDescriptorLeakf is the same as NoFileDescriptorLeak, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NoGoRoutineLeak ¶ added in v2.3.0

func NoGoRoutineLeak(t T, tested func(), msgAndArgs ...any) bool

NoGoRoutineLeak ensures that no goroutine did leak from inside the tested function.

NOTE: only the go routines spawned from inside the tested function are checked for leaks. No filter or configuration is needed to exclude "known go routines".

Resource cleanup should be done inside the tested function, and not using testing.T.Cleanup, as t.Cleanup is called after the leak check.

Edge cases ¶

• if the tested function panics leaving behind leaked goroutines, these are detected.
• if the tested function calls runtime.Goexit (e.g. from testing.T.FailNow) leaving behind leaked goroutines, these are detected.
• if a panic occurs in one of the leaked go routines, it cannot be recovered with certainty and the calling program will usually panic.

Concurrency ¶

NoGoRoutineLeak may be used safely in parallel tests.

Usage ¶

NoGoRoutineLeak(t, func() {
	...
},
"should not leak any go routine",
)

Examples ¶

success: func() {}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNoGoRoutineLeak(t *testing.T)
	success := assert.NoGoRoutineLeak(t, func() {
	})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

package main

import (
	"fmt"
	"sync"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // normally provided by test

	blocker := make(chan struct{})
	var wg sync.WaitGroup

	defer func() {
		// clean resources _after_ the test
		close(blocker)
		wg.Wait()
	}()

	wg.Add(1)
	// This examplifies how a function that leaks a goroutine is detected.
	result := assert.NoGoRoutineLeak(t, func() { // true when there is no leak
		go func() {
			defer wg.Done()
			<-blocker // leaked: blocks until cleanup
		}()
	})

	// Error message from test would typically return the leaked goroutine, e.g.:
	// #	0x69c8e8	github.com/go-openapi/testify/v2/assert_test.ExampleNoGoRoutineLeak.func2.1+0x48	.../assert_adhoc_example_7_test.go:30
	fmt.Printf("has leak: %t", !result)
}

Output:

has leak: true

func NoGoRoutineLeakf ¶ added in v2.3.0

func NoGoRoutineLeakf(t T, tested func(), msg string, args ...any) bool

NoGoRoutineLeakf is the same as NoGoRoutineLeak, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotContains ¶

func NotContains(t T, s any, contains any, msgAndArgs ...any) bool

NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the specified substring or element.

Usage ¶

assertions.NotContains(t, "Hello World", "Earth")
assertions.NotContains(t, ["Hello", "World"], "Earth")
assertions.NotContains(t, {"Hello": "World"}, "Earth")

Examples ¶

success: []string{"A","B"}, "C"
failure: []string{"A","B"}, "B"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotContains(t *testing.T)
	success := assert.NotContains(t, []string{"A", "B"}, "C")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotContainsf ¶

func NotContainsf(t T, s any, contains any, msg string, args ...any) bool

NotContainsf is the same as NotContains, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotElementsMatch ¶

func NotElementsMatch(t T, listA any, listB any, msgAndArgs ...any) (ok bool)

NotElementsMatch asserts that the specified listA(array, slice...) is NOT equal to specified listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, the number of appearances of each of them in both lists should not match. This is an inverse of ElementsMatch.

Usage ¶

assertions.NotElementsMatch(t, []int{1, 1, 2, 3}, []int{1, 1, 2, 3}) -> false
assertions.NotElementsMatch(t, []int{1, 1, 2, 3}, []int{1, 2, 3}) -> true
assertions.NotElementsMatch(t, []int{1, 2, 3}, []int{1, 2, 4}) -> true

Examples ¶

success: []int{1, 2, 3}, []int{1, 2, 4}
failure: []int{1, 3, 2, 3}, []int{1, 3, 3, 2}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotElementsMatch(t *testing.T)
	success := assert.NotElementsMatch(t, []int{1, 2, 3}, []int{1, 2, 4})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotElementsMatchT ¶ added in v2.2.0

func NotElementsMatchT[E comparable](t T, listA []E, listB []E, msgAndArgs ...any) (ok bool)

NotElementsMatchT asserts that the specified listA(array, slice...) is NOT equal to specified listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, the number of appearances of each of them in both lists should not match. This is an inverse of ElementsMatch.

Usage ¶

assertions.NotElementsMatchT(t, []int{1, 1, 2, 3}, []int{1, 1, 2, 3}) -> false
assertions.NotElementsMatchT(t, []int{1, 1, 2, 3}, []int{1, 2, 3}) -> true
assertions.NotElementsMatchT(t, []int{1, 2, 3}, []int{1, 2, 4}) -> true

Examples ¶

success: []int{1, 2, 3}, []int{1, 2, 4}
failure: []int{1, 3, 2, 3}, []int{1, 3, 3, 2}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotElementsMatchT(t *testing.T)
	success := assert.NotElementsMatchT(t, []int{1, 2, 3}, []int{1, 2, 4})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotElementsMatchTf ¶ added in v2.2.0

func NotElementsMatchTf[E comparable](t T, listA []E, listB []E, msg string, args ...any) (ok bool)

NotElementsMatchTf is the same as NotElementsMatchT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotElementsMatchf ¶

func NotElementsMatchf(t T, listA any, listB any, msg string, args ...any) (ok bool)

NotElementsMatchf is the same as NotElementsMatch, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotEmpty ¶

func NotEmpty(t T, object any, msgAndArgs ...any) bool

NotEmpty asserts that the specified object is NOT Empty.

Usage ¶

if assert.NotEmpty(t, obj) {
	assertions.Equal(t, "two", obj[1])
}

Examples ¶

success: "not empty"
failure: ""

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotEmpty(t *testing.T)
	success := assert.NotEmpty(t, "not empty")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotEmptyf ¶

func NotEmptyf(t T, object any, msg string, args ...any) bool

NotEmptyf is the same as NotEmpty, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotEqual ¶

func NotEqual(t T, expected any, actual any, msgAndArgs ...any) bool

NotEqual asserts that the specified values are NOT equal.

Usage ¶

assertions.NotEqual(t, obj1, obj2)

Pointer variable equality is determined based on the equality of the referenced values (as opposed to the memory addresses).

Function equality cannot be determined and will always fail.

Examples ¶

success: 123, 456
failure: 123, 123

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotEqual(t *testing.T)
	success := assert.NotEqual(t, 123, 456)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotEqualT ¶ added in v2.2.0

func NotEqualT[V comparable](t T, expected V, actual V, msgAndArgs ...any) bool

NotEqualT asserts that the specified values of the same comparable type are NOT equal.

See EqualT.

Usage ¶

assertions.NotEqualT(t, obj1, obj2)

Examples ¶

success: 123, 456
failure: 123, 123

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotEqualT(t *testing.T)
	success := assert.NotEqualT(t, 123, 456)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotEqualTf ¶ added in v2.2.0

func NotEqualTf[V comparable](t T, expected V, actual V, msg string, args ...any) bool

NotEqualTf is the same as NotEqualT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotEqualValues ¶

func NotEqualValues(t T, expected any, actual any, msgAndArgs ...any) bool

NotEqualValues asserts that two objects are not equal even when converted to the same type.

Function equality cannot be determined and will always fail.

Usage ¶

assertions.NotEqualValues(t, obj1, obj2)

Examples ¶

success: uint32(123), int32(456)
failure: uint32(123), int32(123)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotEqualValues(t *testing.T)
	success := assert.NotEqualValues(t, uint32(123), int32(456))
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotEqualValuesf ¶

func NotEqualValuesf(t T, expected any, actual any, msg string, args ...any) bool

NotEqualValuesf is the same as NotEqualValues, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotEqualf ¶

func NotEqualf(t T, expected any, actual any, msg string, args ...any) bool

NotEqualf is the same as NotEqual, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotErrorAs ¶

func NotErrorAs(t T, err error, target any, msgAndArgs ...any) bool

NotErrorAs asserts that none of the errors in err's chain matches target, but if so, sets target to that error value.

Usage ¶

assertions.NotErrorAs(t, err, &target)

Examples ¶

success: ErrTest, new(*dummyError)
failure: fmt.Errorf("wrap: %w", &dummyError{}), new(*dummyError)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotErrorAs(t *testing.T)
	success := assert.NotErrorAs(t, assert.ErrTest, new(*dummyError))
	fmt.Printf("success: %t\n", success)

}

type dummyError struct {
}

func (d *dummyError) Error() string {
	return "dummy error"
}

Output:

success: true

func NotErrorAsf ¶

func NotErrorAsf(t T, err error, target any, msg string, args ...any) bool

NotErrorAsf is the same as NotErrorAs, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotErrorIs ¶

func NotErrorIs(t T, err error, target error, msgAndArgs ...any) bool

NotErrorIs asserts that none of the errors in err's chain matches target.

This is a wrapper for errors.Is.

Usage ¶

assertions.NotErrorIs(t, err, io.EOF)

Examples ¶

success: ErrTest, io.EOF
failure: fmt.Errorf("wrap: %w", io.EOF), io.EOF

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"io"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotErrorIs(t *testing.T)
	success := assert.NotErrorIs(t, assert.ErrTest, io.EOF)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotErrorIsf ¶

func NotErrorIsf(t T, err error, target error, msg string, args ...any) bool

NotErrorIsf is the same as NotErrorIs, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotImplements ¶

func NotImplements(t T, interfaceObject any, object any, msgAndArgs ...any) bool

NotImplements asserts that an object does not implement the specified interface.

Usage ¶

assertions.NotImplements(t, (*MyInterface)(nil), new(MyObject))

Examples ¶

success: (*error)(nil), new(testing.T)
failure: ptr(dummyInterface), new(testing.T)

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotImplements(t *testing.T)
	success := assert.NotImplements(t, (*error)(nil), new(testing.T))
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotImplementsf ¶

func NotImplementsf(t T, interfaceObject any, object any, msg string, args ...any) bool

NotImplementsf is the same as NotImplements, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotKind ¶ added in v2.2.0

func NotKind(t T, expectedKind reflect.Kind, object any, msgAndArgs ...any) bool

NotKind asserts that the reflect.Kind of a given object does not match the expected reflect.Kind.

Kind reflects the concrete value stored in the object. The nil value (or interface with nil value) are comparable to reflect.Invalid. See also reflect.Value.Kind.

Usage ¶

assertions.NotKind(t, reflect.Int, "Hello World")

Examples ¶

success: reflect.String, 0
failure: reflect.String, "hello"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"reflect"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotKind(t *testing.T)
	success := assert.NotKind(t, reflect.String, 0)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotKindf ¶ added in v2.2.0

func NotKindf(t T, expectedKind reflect.Kind, object any, msg string, args ...any) bool

NotKindf is the same as NotKind, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotNil ¶

func NotNil(t T, object any, msgAndArgs ...any) bool

NotNil asserts that the specified object is not nil.

Usage ¶

assertions.NotNil(t, err)

Examples ¶

success: "not nil"
failure: nil

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotNil(t *testing.T)
	success := assert.NotNil(t, "not nil")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotNilf ¶

func NotNilf(t T, object any, msg string, args ...any) bool

NotNilf is the same as NotNil, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotPanics ¶

func NotPanics(t T, f func(), msgAndArgs ...any) bool

NotPanics asserts that the code inside the specified function does NOT panic.

Usage ¶

assertions.NotPanics(t, func(){ RemainCalm() })

Examples ¶

success: func() { }
failure: func() { panic("panicking") }

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotPanics(t *testing.T)
	success := assert.NotPanics(t, func() {
	})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotPanicsf ¶

func NotPanicsf(t T, f func(), msg string, args ...any) bool

NotPanicsf is the same as NotPanics, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotRegexp ¶

func NotRegexp(t T, rx any, actual any, msgAndArgs ...any) bool

NotRegexp asserts that a specified regular expression does not match a string.

See Regexp.

Usage ¶

assertions.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
assertions.NotRegexp(t, "^start", "it's not starting")

Examples ¶

success: "^start", "not starting"
failure: "^start", "starting"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotRegexp(t *testing.T)
	success := assert.NotRegexp(t, "^start", "not starting")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotRegexpT ¶ added in v2.2.0

func NotRegexpT[Rex RegExp, ADoc Text](t T, rx Rex, actual ADoc, msgAndArgs ...any) bool

NotRegexpT asserts that a specified regular expression does not match a string.

See RegexpT.

Usage ¶

assertions.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
assertions.NotRegexp(t, "^start", "it's not starting")

Examples ¶

success: "^start", "not starting"
failure: "^start", "starting"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotRegexpT(t *testing.T)
	success := assert.NotRegexpT(t, "^start", "not starting")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotRegexpTf ¶ added in v2.2.0

func NotRegexpTf[Rex RegExp, ADoc Text](t T, rx Rex, actual ADoc, msg string, args ...any) bool

NotRegexpTf is the same as NotRegexpT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotRegexpf ¶

func NotRegexpf(t T, rx any, actual any, msg string, args ...any) bool

NotRegexpf is the same as NotRegexp, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotSame ¶

func NotSame(t T, expected any, actual any, msgAndArgs ...any) bool

NotSame asserts that two pointers do not reference the same object.

See Same.

Usage ¶

assertions.NotSame(t, ptr1, ptr2)

Examples ¶

success: &staticVar, ptr("static string")
failure: &staticVar, staticVarPtr

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotSame(t *testing.T)
	success := assert.NotSame(t, &staticVar, ptr("static string"))
	fmt.Printf("success: %t\n", success)

}

//nolint:gochecknoglobals // this is on purpose to share a common pointer when testing
var staticVar = "static string"

func ptr[T any](value T) *T {
	p := value

	return &p
}

Output:

success: true

func NotSameT ¶ added in v2.2.0

func NotSameT[P any](t T, expected *P, actual *P, msgAndArgs ...any) bool

NotSameT asserts that two pointers do not reference the same object.

See SameT.

Usage ¶

assertions.NotSameT(t, ptr1, ptr2)

Examples ¶

success: &staticVar, ptr("static string")
failure: &staticVar, staticVarPtr

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotSameT(t *testing.T)
	success := assert.NotSameT(t, &staticVar, ptr("static string"))
	fmt.Printf("success: %t\n", success)

}

//nolint:gochecknoglobals // this is on purpose to share a common pointer when testing
var staticVar = "static string"

func ptr[T any](value T) *T {
	p := value

	return &p
}

Output:

success: true

func NotSameTf ¶ added in v2.2.0

func NotSameTf[P any](t T, expected *P, actual *P, msg string, args ...any) bool

NotSameTf is the same as NotSameT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotSamef ¶

func NotSamef(t T, expected any, actual any, msg string, args ...any) bool

NotSamef is the same as NotSame, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotSortedT ¶ added in v2.2.0

func NotSortedT[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msgAndArgs ...any) bool

NotSortedT asserts that the slice of Ordered is NOT sorted (i.e. non-strictly increasing).

Unlike IsDecreasingT, it accepts slices that are neither increasing nor decreasing.

Usage ¶

assertions.NotSortedT(t, []int{3, 2, 3})
assertions.NotSortedT(t, []float{2, 1})
assertions.NotSortedT(t, []string{"b", "a"})

Examples ¶

success: []int{3, 1, 3}
failure: []int{1, 4, 8}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotSortedT(t *testing.T)
	success := assert.NotSortedT(t, []int{3, 1, 3})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotSortedTf ¶ added in v2.2.0

func NotSortedTf[OrderedSlice ~[]E, E Ordered](t T, collection OrderedSlice, msg string, args ...any) bool

NotSortedTf is the same as NotSortedT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotSubset ¶

func NotSubset(t T, list any, subset any, msgAndArgs ...any) (ok bool)

NotSubset asserts that the list (array, slice, or map) does NOT contain all elements given in the subset (array, slice, or map). Map elements are key-value pairs unless compared with an array or slice where only the map key is evaluated.

Usage ¶

assertions.NotSubset(t, [1, 3, 4], [1, 2])
assertions.NotSubset(t, {"x": 1, "y": 2}, {"z": 3})
assertions.NotSubset(t, [1, 3, 4], {1: "one", 2: "two"})
assertions.NotSubset(t, {"x": 1, "y": 2}, ["z"])

Examples ¶

success: []int{1, 2, 3}, []int{4, 5}
failure: []int{1, 2, 3}, []int{1, 2}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotSubset(t *testing.T)
	success := assert.NotSubset(t, []int{1, 2, 3}, []int{4, 5})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotSubsetf ¶

func NotSubsetf(t T, list any, subset any, msg string, args ...any) (ok bool)

NotSubsetf is the same as NotSubset, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func NotZero ¶

func NotZero(t T, i any, msgAndArgs ...any) bool

NotZero asserts that i is not the zero value for its type.

Usage ¶

assertions.NotZero(t, obj)

Examples ¶

success: 1
failure: 0

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotZero(t *testing.T)
	success := assert.NotZero(t, 1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func NotZerof ¶

func NotZerof(t T, i any, msg string, args ...any) bool

NotZerof is the same as NotZero, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func ObjectsAreEqual ¶

func ObjectsAreEqual(expected any, actual any) bool

ObjectsAreEqual determines if two objects are considered equal.

This function does no assertion of any kind.

func ObjectsAreEqualValues ¶

func ObjectsAreEqualValues(expected any, actual any) bool

ObjectsAreEqualValues gets whether two objects are equal, or if their values are equal.

func Panics ¶

func Panics(t T, f func(), msgAndArgs ...any) bool

Panics asserts that the code inside the specified function panics.

Usage ¶

assertions.Panics(t, func(){ GoCrazy() })

Examples ¶

success: func() { panic("panicking") }
failure: func() { }

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestPanics(t *testing.T)
	success := assert.Panics(t, func() {
		panic("panicking")
	})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func PanicsWithError ¶

func PanicsWithError(t T, errString string, f func(), msgAndArgs ...any) bool

PanicsWithError asserts that the code inside the specified function panics, and that the recovered panic value is an error that satisfies the EqualError comparison.

Usage ¶

assertions.PanicsWithError(t, "crazy error", func(){ GoCrazy() })

Examples ¶

success: ErrTest.Error(), func() { panic(ErrTest) }
failure: ErrTest.Error(), func() { }

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestPanicsWithError(t *testing.T)
	success := assert.PanicsWithError(t, assert.ErrTest.Error(), func() {
		panic(assert.ErrTest)
	})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func PanicsWithErrorf ¶

func PanicsWithErrorf(t T, errString string, f func(), msg string, args ...any) bool

PanicsWithErrorf is the same as PanicsWithError, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func PanicsWithValue ¶

func PanicsWithValue(t T, expected any, f func(), msgAndArgs ...any) bool

PanicsWithValue asserts that the code inside the specified function panics, and that the recovered panic value equals the expected panic value.

Usage ¶

assertions.PanicsWithValue(t, "crazy error", func(){ GoCrazy() })

Examples ¶

success: "panicking", func() { panic("panicking") }
failure: "panicking", func() { }

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestPanicsWithValue(t *testing.T)
	success := assert.PanicsWithValue(t, "panicking", func() {
		panic("panicking")
	})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func PanicsWithValuef ¶

func PanicsWithValuef(t T, expected any, f func(), msg string, args ...any) bool

PanicsWithValuef is the same as PanicsWithValue, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Panicsf ¶

func Panicsf(t T, f func(), msg string, args ...any) bool

Panicsf is the same as Panics, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Positive ¶

func Positive(t T, e any, msgAndArgs ...any) bool

Positive asserts that the specified element is strictly positive.

Usage ¶

assertions.Positive(t, 1)
assertions.Positive(t, 1.23)

Examples ¶

success: 1
failure: -1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestPositive(t *testing.T)
	success := assert.Positive(t, 1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func PositiveT ¶ added in v2.2.0

func PositiveT[SignedNumber SignedNumeric](t T, e SignedNumber, msgAndArgs ...any) bool

PositiveT asserts that the specified element of a signed numeric type is strictly positive.

Usage ¶

assertions.PositiveT(t, 1)
assertions.PositiveT(t, 1.23)

Examples ¶

success: 1
failure: -1

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestPositiveT(t *testing.T)
	success := assert.PositiveT(t, 1)
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func PositiveTf ¶ added in v2.2.0

func PositiveTf[SignedNumber SignedNumeric](t T, e SignedNumber, msg string, args ...any) bool

PositiveTf is the same as PositiveT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Positivef ¶

func Positivef(t T, e any, msg string, args ...any) bool

Positivef is the same as Positive, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Regexp ¶

func Regexp(t T, rx any, actual any, msgAndArgs ...any) bool

Regexp asserts that a specified regular expression matches a string.

The regular expression may be passed as a regexp.Regexp, a string or a []byte and will be compiled.

The actual argument to be matched may be a string, []byte or anything that prints as a string with fmt.Sprint.

Usage ¶

assertions.Regexp(t, regexp.MustCompile("start"), "it's starting")
assertions.Regexp(t, "start...$", "it's not starting")

Examples ¶

success: "^start", "starting"
failure: "^start", "not starting"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestRegexp(t *testing.T)
	success := assert.Regexp(t, "^start", "starting")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func RegexpT ¶ added in v2.2.0

func RegexpT[Rex RegExp, ADoc Text](t T, rx Rex, actual ADoc, msgAndArgs ...any) bool

RegexpT asserts that a specified regular expression matches a string.

The actual argument to be matched may be a string or []byte.

See Regexp.

Examples ¶

success: "^start", "starting"
failure: "^start", "not starting"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestRegexpT(t *testing.T)
	success := assert.RegexpT(t, "^start", "starting")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func RegexpTf ¶ added in v2.2.0

func RegexpTf[Rex RegExp, ADoc Text](t T, rx Rex, actual ADoc, msg string, args ...any) bool

RegexpTf is the same as RegexpT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Regexpf ¶

func Regexpf(t T, rx any, actual any, msg string, args ...any) bool

Regexpf is the same as Regexp, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Same ¶

func Same(t T, expected any, actual any, msgAndArgs ...any) bool

Same asserts that two pointers reference the same object.

Both arguments must be pointer variables.

Pointer variable sameness is determined based on the equality of both type and value.

Unlike Equal pointers, Same pointers point to the same memory address.

Usage ¶

assertions.Same(t, ptr1, ptr2)

Examples ¶

success: &staticVar, staticVarPtr
failure: &staticVar, ptr("static string")

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestSame(t *testing.T)
	success := assert.Same(t, &staticVar, staticVarPtr)
	fmt.Printf("success: %t\n", success)

}

//nolint:gochecknoglobals // this is on purpose to share a common pointer when testing
var (
	staticVar    = "static string"
	staticVarPtr = &staticVar
)

Output:

success: true

func SameT ¶ added in v2.2.0

func SameT[P any](t T, expected *P, actual *P, msgAndArgs ...any) bool

SameT asserts that two pointers of the same type reference the same object.

See Same.

Usage ¶

assertions.SameT(t, ptr1, ptr2)

Examples ¶

success: &staticVar, staticVarPtr
failure: &staticVar, ptr("static string")

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestSameT(t *testing.T)
	success := assert.SameT(t, &staticVar, staticVarPtr)
	fmt.Printf("success: %t\n", success)

}

//nolint:gochecknoglobals // this is on purpose to share a common pointer when testing
var (
	staticVar    = "static string"
	staticVarPtr = &staticVar
)

Output:

success: true

func SameTf ¶ added in v2.2.0

func SameTf[P any](t T, expected *P, actual *P, msg string, args ...any) bool

SameTf is the same as SameT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func Samef ¶

func Samef(t T, expected any, actual any, msg string, args ...any) bool

Samef is the same as Same, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func SeqContainsT ¶ added in v2.2.0

func SeqContainsT[E comparable](t T, iter iter.Seq[E], element E, msgAndArgs ...any) bool

SeqContainsT asserts that the specified iterator contains a comparable element.

The sequence may not be consumed entirely: the iteration stops as soon as the specified element is found.

Go native comparable types are explained there: comparable-types.

Usage ¶

assertions.SeqContainsT(t, slices.Values([]{"Hello","World"}), "World")

Examples ¶

success: slices.Values([]string{"A","B"}), "A"
failure: slices.Values([]string{"A","B"}), "C"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"slices"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestSeqContainsT(t *testing.T)
	success := assert.SeqContainsT(t, slices.Values([]string{"A", "B"}), "A")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func SeqContainsTf ¶ added in v2.2.0

func SeqContainsTf[E comparable](t T, iter iter.Seq[E], element E, msg string, args ...any) bool

SeqContainsTf is the same as SeqContainsT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func SeqNotContainsT ¶ added in v2.2.0

func SeqNotContainsT[E comparable](t T, iter iter.Seq[E], element E, msgAndArgs ...any) bool

SeqNotContainsT asserts that the specified iterator does not contain a comparable element.

See SeqContainsT.

Usage ¶

assertions.SeqContainsT(t, slices.Values([]{"Hello","World"}), "World")

Examples ¶

success: slices.Values([]string{"A","B"}), "C"
failure: slices.Values([]string{"A","B"}), "A"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"slices"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestSeqNotContainsT(t *testing.T)
	success := assert.SeqNotContainsT(t, slices.Values([]string{"A", "B"}), "C")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func SeqNotContainsTf ¶ added in v2.2.0

func SeqNotContainsTf[E comparable](t T, iter iter.Seq[E], element E, msg string, args ...any) bool

SeqNotContainsTf is the same as SeqNotContainsT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func SliceContainsT ¶ added in v2.2.0

func SliceContainsT[Slice ~[]E, E comparable](t T, s Slice, element E, msgAndArgs ...any) bool

SliceContainsT asserts that the specified slice contains a comparable element.

Go native comparable types are explained there: comparable-types.

Usage ¶

assertions.SliceContainsT(t, []{"Hello","World"}, "World")

Examples ¶

success: []string{"A","B"}, "A"
failure: []string{"A","B"}, "C"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestSliceContainsT(t *testing.T)
	success := assert.SliceContainsT(t, []string{"A", "B"}, "A")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func SliceContainsTf ¶ added in v2.2.0

func SliceContainsTf[Slice ~[]E, E comparable](t T, s Slice, element E, msg string, args ...any) bool

SliceContainsTf is the same as SliceContainsT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func SliceNotContainsT ¶ added in v2.2.0

func SliceNotContainsT[Slice ~[]E, E comparable](t T, s Slice, element E, msgAndArgs ...any) bool

SliceNotContainsT asserts that the specified slice does not contain a comparable element.

See SliceContainsT.

Usage ¶

assertions.SliceNotContainsT(t, []{"Hello","World"}, "hi")

Examples ¶

success: []string{"A","B"}, "C"
failure: []string{"A","B"}, "A"

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestSliceNotContainsT(t *testing.T)
	success := assert.SliceNotContainsT(t, []string{"A", "B"}, "C")
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func SliceNotContainsTf ¶ added in v2.2.0

func SliceNotContainsTf[Slice ~[]E, E comparable](t T, s Slice, element E, msg string, args ...any) bool

SliceNotContainsTf is the same as SliceNotContainsT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func SliceNotSubsetT ¶ added in v2.2.0

func SliceNotSubsetT[Slice ~[]E, E comparable](t T, list Slice, subset Slice, msgAndArgs ...any) (ok bool)

SliceNotSubsetT asserts that a slice of comparable elements does not contain all the elements given in the subset.

Usage ¶

assertions.SliceNotSubsetT(t, []int{1, 2, 3}, []int{1, 4})

Examples ¶

success: []int{1, 2, 3}, []int{4, 5}
failure: []int{1, 2, 3}, []int{1, 2}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestSliceNotSubsetT(t *testing.T)
	success := assert.SliceNotSubsetT(t, []int{1, 2, 3}, []int{4, 5})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func SliceNotSubsetTf ¶ added in v2.2.0

func SliceNotSubsetTf[Slice ~[]E, E comparable](t T, list Slice, subset Slice, msg string, args ...any) (ok bool)

SliceNotSubsetTf is the same as SliceNotSubsetT, but it accepts a format string to format arguments like fmt.Printf.

Upon failure, the test T is marked as failed and continues execution.

func SliceSubsetT ¶ added in v2.2.0

func SliceSubsetT[Slice ~[]E, E comparable](t T, list Slice, subset Slice, msgAndArgs ...any) (ok bool)

SliceSubsetT asserts that a slice of comparable elements contains all the elements given in the subset.

Usage ¶

assertions.SliceSubsetT(t, []int{1, 2, 3}, []int{1, 2})

Examples ¶

success: []int{1, 2, 3}, []int{1, 2}
failure: []int{1, 2, 3}, []int{4, 5}

Upon failure, the test T is marked as failed and continues execution.

package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestSliceSubsetT(t *testing.T)
	success := assert.SliceSubsetT(t, []int{1, 2, 3}, []int{1, 2})
	fmt.Printf("success: %t\n", success)

}

Output:

success: true

func SliceSubsetTf ¶ added in v2.2.0

func SliceSubsetTf[Slice ~[]E, E comparable](t T, list Slice, subset Slice, msg string, args ...any) (ok bool)