require

func CallerInfo ¶ added in v2.1.0

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 Comparison, msgAndArgs ...any)

Condition uses a Comparison 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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Condition(t, func() bool {
		return true
	})
	fmt.Println("passed")

}

Output:

passed

func Conditionf ¶

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

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

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

func Contains ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Contains(t, []string{"A", "B"}, "A")
	fmt.Println("passed")

}

Output:

passed

func Containsf ¶

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

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

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

func DirExists ¶

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

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 stops execution.

package main

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

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

func main() {
	t := new(testing.T)
	require.DirExists(t, filepath.Join(testDataPath(), "existing_dir"))
	fmt.Println("passed")

}

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

Output:

passed

func DirExistsf ¶

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

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

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

func DirNotExists ¶ added in v2.2.0

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

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 stops execution.

package main

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

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

func main() {
	t := new(testing.T)
	require.DirNotExists(t, filepath.Join(testDataPath(), "non_existing_dir"))
	fmt.Println("passed")

}

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

Output:

passed

func DirNotExistsf ¶ added in v2.2.0

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

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

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

func ElementsMatch ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.ElementsMatch(t, []int{1, 3, 2, 3}, []int{1, 3, 3, 2})
	fmt.Println("passed")

}

Output:

passed

func ElementsMatchT ¶ added in v2.2.0

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.ElementsMatchT(t, []int{1, 3, 2, 3}, []int{1, 3, 3, 2})
	fmt.Println("passed")

}

Output:

passed

func ElementsMatchTf ¶ added in v2.2.0

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

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

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

func ElementsMatchf ¶

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

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

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

func Empty ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Empty(t, "")
	fmt.Println("passed")

}

Output:

passed

func Emptyf ¶

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

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

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

func Equal ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Equal(t, 123, 123)
	fmt.Println("passed")

}

Output:

passed

func EqualError ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.EqualError(t, require.ErrTest, "assert.ErrTest general error for testing")
	fmt.Println("passed")

}

Output:

passed

func EqualErrorf ¶

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

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

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

func EqualExportedValues ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.EqualExportedValues(t, &dummyStruct{A: "a", b: 1}, &dummyStruct{A: "a", b: 2})
	fmt.Println("passed")

}

type dummyStruct struct {
	A string
	b int
}

Output:

passed

func EqualExportedValuesf ¶

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

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

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

func EqualT ¶ added in v2.2.0

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.EqualT(t, 123, 123)
	fmt.Println("passed")

}

Output:

passed

func EqualTf ¶ added in v2.2.0

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

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

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

func EqualValues ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.EqualValues(t, uint32(123), int32(123))
	fmt.Println("passed")

}

Output:

passed

func EqualValuesf ¶

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

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

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

func Equalf ¶

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

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

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

func Error ¶

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

Error asserts that a function returned a non-nil error (ie. 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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Error(t, require.ErrTest)
	fmt.Println("passed")

}

Output:

passed

func ErrorAs ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.ErrorAs(t, fmt.Errorf("wrap: %w", &dummyError{}), new(*dummyError))
	fmt.Println("passed")

}

type dummyError struct {
}

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

Output:

passed

func ErrorAsf ¶

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

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

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

func ErrorContains ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.ErrorContains(t, require.ErrTest, "general error")
	fmt.Println("passed")

}

Output:

passed

func ErrorContainsf ¶

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

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

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

func ErrorIs ¶

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

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 stops execution.

package main

import (
	"fmt"
	"io"
	"testing"

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

func main() {
	t := new(testing.T)
	require.ErrorIs(t, fmt.Errorf("wrap: %w", io.EOF), io.EOF)
	fmt.Println("passed")

}

Output:

passed

func ErrorIsf ¶

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

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

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

func Errorf ¶

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

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

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

func Eventually ¶

func Eventually(t T, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...any)

Eventually asserts that the given condition will be met in waitFor time, periodically checking the target function on each tick.

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

If the condition takes longer than waitFor 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)

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.

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

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 stops execution.

package main

import (
	"fmt"
	"testing"
	"time"

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

func main() {
	t := new(testing.T)
	require.Eventually(t, func() bool {
		return true
	}, 100*time.Millisecond, 20*time.Millisecond)
	fmt.Println("passed")

}

Output:

passed

func EventuallyWithT ¶

func EventuallyWithT(t T, condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...any)

EventuallyWithT asserts that the given condition will be met in waitFor time, 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 waitFor, the collected errors from the last tick are copied to t.

Calling [CollectT.FailNow] cancels the condition immediately and fails the assertion.

Usage ¶

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

assertions.EventuallyWithT(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 stops execution.

package main

import (
	"fmt"
	"testing"
	"time"

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

func main() {
	t := new(testing.T)
	require.EventuallyWithT(t, func(c *assert.CollectT) {
		assert.True(c, true)
	}, 100*time.Millisecond, 20*time.Millisecond)
	fmt.Println("passed")

}

Output:

passed

func EventuallyWithTf ¶

func EventuallyWithTf(t T, condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...any)

EventuallyWithTf is the same as EventuallyWithT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Eventuallyf ¶

func Eventuallyf(t T, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...any)

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

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

func Exactly ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Exactly(t, int32(123), int32(123))
	fmt.Println("passed")

}

Output:

passed

func Exactlyf ¶

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

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

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

func Fail ¶

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

Fail reports a failure through.

Usage ¶

assertions.Fail(t, "failed")

Examples ¶

failure: "failed"

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

func FailNow ¶

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

FailNow fails test.

Usage ¶

assertions.FailNow(t, "failed")

Examples ¶

failure: "failed"

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

func FailNowf ¶

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

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

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

func Failf ¶

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

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

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

func False ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.False(t, 1 == 0)
	fmt.Println("passed")

}

Output:

passed

func FalseT ¶ added in v2.2.0

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

FalseT asserts that the specified value is false.

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.FalseT(t, 1 == 0)
	fmt.Println("passed")

}

Output:

passed

func FalseTf ¶ added in v2.2.0

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

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

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

func Falsef ¶

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

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

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

func FileEmpty ¶ added in v2.1.0

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

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 stops execution.

package main

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

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

func main() {
	t := new(testing.T)
	require.FileEmpty(t, filepath.Join(testDataPath(), "empty_file"))
	fmt.Println("passed")

}

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

Output:

passed

func FileEmptyf ¶ added in v2.1.0

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

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

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

func FileExists ¶

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

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 stops execution.

package main

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

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

func main() {
	t := new(testing.T)
	require.FileExists(t, filepath.Join(testDataPath(), "existing_file"))
	fmt.Println("passed")

}

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

Output:

passed

func FileExistsf ¶

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

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

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

func FileNotEmpty ¶ added in v2.1.0

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

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 stops execution.

package main

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

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

func main() {
	t := new(testing.T)
	require.FileNotEmpty(t, filepath.Join(testDataPath(), "existing_file"))
	fmt.Println("passed")

}

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

Output:

passed

func FileNotEmptyf ¶ added in v2.1.0

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

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

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

func FileNotExists ¶ added in v2.2.0

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

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 stops execution.

package main

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

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

func main() {
	t := new(testing.T)
	require.FileNotExists(t, filepath.Join(testDataPath(), "non_existing_file"))
	fmt.Println("passed")

}

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

Output:

passed

func FileNotExistsf ¶ added in v2.2.0

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

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

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

func Greater ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Greater(t, 2, 1)
	fmt.Println("passed")

}

Output:

passed

func GreaterOrEqual ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.GreaterOrEqual(t, 2, 1)
	fmt.Println("passed")

}

Output:

passed

func GreaterOrEqualT ¶ added in v2.2.0

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.GreaterOrEqualT(t, 2, 1)
	fmt.Println("passed")

}

Output:

passed

func GreaterOrEqualTf ¶ added in v2.2.0

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

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

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

func GreaterOrEqualf ¶

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

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

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

func GreaterT ¶ added in v2.2.0

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.GreaterT(t, 2, 1)
	fmt.Println("passed")

}

Output:

passed

func GreaterTf ¶ added in v2.2.0

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

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

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

func Greaterf ¶

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

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

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

func HTTPBody ¶ added in v2.1.0

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)

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 stops execution.

package main

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

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

func main() {
	t := new(testing.T)
	require.HTTPBodyContains(t, httpBody, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!")
	fmt.Println("passed")

}

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

Output:

passed

func HTTPBodyContainsf ¶

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

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

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

func HTTPBodyNotContains ¶

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

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 stops execution.

package main

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

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

func main() {
	t := new(testing.T)
	require.HTTPBodyNotContains(t, httpBody, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, Bob!")
	fmt.Println("passed")

}

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

Output:

passed

func HTTPBodyNotContainsf ¶

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

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

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

func HTTPError ¶

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

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 stops execution.

package main

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

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

func main() {
	t := new(testing.T)
	require.HTTPError(t, httpError, "GET", "/", nil)
	fmt.Println("passed")

}

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

Output:

passed

func HTTPErrorf ¶

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

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

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

func HTTPRedirect ¶

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

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 stops execution.

package main

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

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

func main() {
	t := new(testing.T)
	require.HTTPRedirect(t, httpRedirect, "GET", "/", nil)
	fmt.Println("passed")

}

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

Output:

passed

func HTTPRedirectf ¶

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

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

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

func HTTPStatusCode ¶

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

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 stops execution.

package main

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

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

func main() {
	t := new(testing.T)
	require.HTTPStatusCode(t, httpOK, "GET", "/", nil, http.StatusOK)
	fmt.Println("passed")

}

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

Output:

passed

func HTTPStatusCodef ¶

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

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

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

func HTTPSuccess ¶

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

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 stops execution.

package main

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

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

func main() {
	t := new(testing.T)
	require.HTTPSuccess(t, httpOK, "GET", "/", nil)
	fmt.Println("passed")

}

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

Output:

passed

func HTTPSuccessf ¶

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

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

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

func Implements ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Implements(t, ptr(dummyInterface), new(testing.T))
	fmt.Println("passed")

}

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

	dummyInterface require.T
)

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

	return &p
}

Output:

passed

func Implementsf ¶

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

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

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

func InDelta ¶

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

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 (eg. uint64), prefer InDeltaT to preserve the original type.

Behavior with IEEE floating point arithmetics ¶

• 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.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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.InDelta(t, 1.0, 1.01, 0.02)
	fmt.Println("passed")

}

Output:

passed

func InDeltaMapValues ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.InDeltaMapValues(t, map[string]float64{"a": 1.0}, map[string]float64{"a": 1.01}, 0.02)
	fmt.Println("passed")

}

Output:

passed

func InDeltaMapValuesf ¶

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

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

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

func InDeltaSlice ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.InDeltaSlice(t, []float64{1.0, 2.0}, []float64{1.01, 2.01}, 0.02)
	fmt.Println("passed")

}

Output:

passed

func InDeltaSlicef ¶

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

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

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

func InDeltaT ¶ added in v2.2.0

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

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 arithmetics ¶

• 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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.InDeltaT(t, 1.0, 1.01, 0.02)
	fmt.Println("passed")

}

Output:

passed

func InDeltaTf ¶ added in v2.2.0

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

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

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

func InDeltaf ¶

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

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

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

func InEpsilon ¶

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

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

Behavior with IEEE floating point arithmetics ¶

• 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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.InEpsilon(t, 100.0, 101.0, 0.02)
	fmt.Println("passed")

}

Output:

passed

func InEpsilonSlice ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.InEpsilonSlice(t, []float64{100.0, 200.0}, []float64{101.0, 202.0}, 0.02)
	fmt.Println("passed")

}

Output:

passed

func InEpsilonSlicef ¶

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

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

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

func InEpsilonT ¶ added in v2.2.0

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

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 arithmetics ¶

• 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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.InEpsilonT(t, 100.0, 101.0, 0.02)
	fmt.Println("passed")

}

Output:

passed

func InEpsilonTf ¶ added in v2.2.0

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

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

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

func InEpsilonf ¶

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

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

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

func IsDecreasing ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsDecreasing(t, []int{3, 2, 1})
	fmt.Println("passed")

}

Output:

passed

func IsDecreasingT ¶ added in v2.2.0

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsDecreasingT(t, []int{3, 2, 1})
	fmt.Println("passed")

}

Output:

passed

func IsDecreasingTf ¶ added in v2.2.0

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

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

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

func IsDecreasingf ¶

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

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

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

func IsIncreasing ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsIncreasing(t, []int{1, 2, 3})
	fmt.Println("passed")

}

Output:

passed

func IsIncreasingT ¶ added in v2.2.0

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsIncreasingT(t, []int{1, 2, 3})
	fmt.Println("passed")

}

Output:

passed

func IsIncreasingTf ¶ added in v2.2.0

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

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

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

func IsIncreasingf ¶

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

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

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

func IsNonDecreasing ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsNonDecreasing(t, []int{1, 1, 2})
	fmt.Println("passed")

}

Output:

passed

func IsNonDecreasingT ¶ added in v2.2.0

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsNonDecreasingT(t, []int{1, 1, 2})
	fmt.Println("passed")

}

Output:

passed

func IsNonDecreasingTf ¶ added in v2.2.0

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

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

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

func IsNonDecreasingf ¶

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

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

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

func IsNonIncreasing ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsNonIncreasing(t, []int{2, 1, 1})
	fmt.Println("passed")

}

Output:

passed

func IsNonIncreasingT ¶ added in v2.2.0

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsNonIncreasingT(t, []int{2, 1, 1})
	fmt.Println("passed")

}

Output:

passed

func IsNonIncreasingTf ¶ added in v2.2.0

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

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

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

func IsNonIncreasingf ¶

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

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

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

func IsNotOfTypeT ¶ added in v2.2.0

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

IsNotOfTypeT asserts that an object is 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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsNotOfTypeT[myType](t, 123.123)
	fmt.Println("passed")

}

type myType float64

Output:

passed

func IsNotOfTypeTf ¶ added in v2.2.0

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

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

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

func IsNotType ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsNotType(t, int32(123), int64(456))
	fmt.Println("passed")

}

Output:

passed

func IsNotTypef ¶

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

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

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

func IsOfTypeT ¶ added in v2.2.0

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsOfTypeT[myType](t, myType(123.123))
	fmt.Println("passed")

}

type myType float64

Output:

passed

func IsOfTypeTf ¶ added in v2.2.0

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

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

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

func IsType ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.IsType(t, 123, 456)
	fmt.Println("passed")

}

Output:

passed

func IsTypef ¶

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

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

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

func JSONEq ¶

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

JSONEq asserts that two JSON strings are 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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
	fmt.Println("passed")

}

Output:

passed

func JSONEqBytes ¶ added in v2.0.2

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

JSONEqBytes asserts that two JSON slices of bytes are 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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.JSONEqBytes(t, []byte(`{"hello": "world", "foo": "bar"}`), []byte(`{"foo": "bar", "hello": "world"}`))
	fmt.Println("passed")

}

Output:

passed

func JSONEqBytesf ¶ added in v2.0.2

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

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

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

func JSONEqT ¶ added in v2.2.0

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

JSONEqT asserts that two JSON documents are 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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.JSONEqT(t, `{"hello": "world", "foo": "bar"}`, []byte(`{"foo": "bar", "hello": "world"}`))
	fmt.Println("passed")

}

Output:

passed

func JSONEqTf ¶ added in v2.2.0

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

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

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

func JSONEqf ¶

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

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

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

func Kind ¶ added in v2.2.0

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

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 stops execution.

package main

import (
	"fmt"
	"reflect"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Kind(t, reflect.String, "hello")
	fmt.Println("passed")

}

Output:

passed

func Kindf ¶ added in v2.2.0

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

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

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

func Len ¶

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

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 or a channel.

See also reflect.Len.

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Len(t, []string{"A", "B"}, 2)
	fmt.Println("passed")

}

Output:

passed

func Lenf ¶

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

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

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

func Less ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Less(t, 1, 2)
	fmt.Println("passed")

}

Output:

passed

func LessOrEqual ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.LessOrEqual(t, 1, 2)
	fmt.Println("passed")

}

Output:

passed

func LessOrEqualT ¶ added in v2.2.0

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.LessOrEqualT(t, 1, 2)
	fmt.Println("passed")

}

Output:

passed

func LessOrEqualTf ¶ added in v2.2.0

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

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

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

func LessOrEqualf ¶

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

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

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

func LessT ¶ added in v2.2.0

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.LessT(t, 1, 2)
	fmt.Println("passed")

}

Output:

passed

func LessTf ¶ added in v2.2.0

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

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

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

func Lessf ¶

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

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

Upon failure, the test T is marked as failed and stops 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)

MapContainsT asserts that the specified map contains a key.

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.MapContainsT(t, map[string]string{"A": "B"}, "A")
	fmt.Println("passed")

}

Output:

passed

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)

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

Upon failure, the test T is marked as failed and stops 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)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.MapNotContainsT(t, map[string]string{"A": "B"}, "C")
	fmt.Println("passed")

}

Output:

passed

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)

MapNotContainsTf is the same as MapNotContainsT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Negative ¶

func Negative(t T, e any, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Negative(t, -1)
	fmt.Println("passed")

}

Output:

passed

func NegativeT ¶ added in v2.2.0

func NegativeT[SignedNumber SignedNumeric](t T, e SignedNumber, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NegativeT(t, -1)
	fmt.Println("passed")

}

Output:

passed

func NegativeTf ¶ added in v2.2.0

func NegativeTf[SignedNumber SignedNumeric](t T, e SignedNumber, msg string, args ...any)

NegativeTf is the same as NegativeT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Negativef ¶

func Negativef(t T, e any, msg string, args ...any)

Negativef is the same as Negative, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Never ¶

func Never(t T, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...any)

Never asserts that the given condition is never satisfied within waitFor time, periodically checking the target function at each tick.

Never is the opposite of Eventually. It succeeds if the waitFor 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)

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.

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

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 stops execution.

package main

import (
	"fmt"
	"testing"
	"time"

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

func main() {
	t := new(testing.T)
	require.Never(t, func() bool {
		return false
	}, 100*time.Millisecond, 20*time.Millisecond)
	fmt.Println("passed")

}

Output:

passed

func Neverf ¶

func Neverf(t T, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...any)

Neverf is the same as Never, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Nil ¶

func Nil(t T, object any, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Nil(t, nil)
	fmt.Println("passed")

}

Output:

passed

func Nilf ¶

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

Nilf is the same as Nil, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NoError ¶

func NoError(t T, err error, msgAndArgs ...any)

NoError asserts that a function returned a nil error (ie. 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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NoError(t, nil)
	fmt.Println("passed")

}

Output:

passed

func NoErrorf ¶

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

NoErrorf is the same as NoError, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotContains ¶

func NotContains(t T, s any, contains any, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotContains(t, []string{"A", "B"}, "C")
	fmt.Println("passed")

}

Output:

passed

func NotContainsf ¶

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

NotContainsf is the same as NotContains, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotElementsMatch ¶

func NotElementsMatch(t T, listA any, listB any, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotElementsMatch(t, []int{1, 2, 3}, []int{1, 2, 4})
	fmt.Println("passed")

}

Output:

passed

func NotElementsMatchT ¶ added in v2.2.0

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotElementsMatchT(t, []int{1, 2, 3}, []int{1, 2, 4})
	fmt.Println("passed")

}

Output:

passed

func NotElementsMatchTf ¶ added in v2.2.0

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

NotElementsMatchTf is the same as NotElementsMatchT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotElementsMatchf ¶

func NotElementsMatchf(t T, listA any, listB any, msg string, args ...any)

NotElementsMatchf is the same as NotElementsMatch, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotEmpty ¶

func NotEmpty(t T, object any, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotEmpty(t, "not empty")
	fmt.Println("passed")

}

Output:

passed

func NotEmptyf ¶

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

NotEmptyf is the same as NotEmpty, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotEqual ¶

func NotEqual(t T, expected any, actual any, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotEqual(t, 123, 456)
	fmt.Println("passed")

}

Output:

passed

func NotEqualT ¶ added in v2.2.0

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotEqualT(t, 123, 456)
	fmt.Println("passed")

}

Output:

passed

func NotEqualTf ¶ added in v2.2.0

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

NotEqualTf is the same as NotEqualT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotEqualValues ¶

func NotEqualValues(t T, expected any, actual any, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotEqualValues(t, uint32(123), int32(456))
	fmt.Println("passed")

}

Output:

passed

func NotEqualValuesf ¶

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

NotEqualValuesf is the same as NotEqualValues, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotEqualf ¶

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

NotEqualf is the same as NotEqual, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotErrorAs ¶

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotErrorAs(t, require.ErrTest, new(*dummyError))
	fmt.Println("passed")

}

type dummyError struct {
}

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

Output:

passed

func NotErrorAsf ¶

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

NotErrorAsf is the same as NotErrorAs, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotErrorIs ¶

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

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 stops execution.

package main

import (
	"fmt"
	"io"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotErrorIs(t, require.ErrTest, io.EOF)
	fmt.Println("passed")

}

Output:

passed

func NotErrorIsf ¶

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

NotErrorIsf is the same as NotErrorIs, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotImplements ¶

func NotImplements(t T, interfaceObject any, object any, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotImplements(t, (*error)(nil), new(testing.T))
	fmt.Println("passed")

}

Output:

passed

func NotImplementsf ¶

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

NotImplementsf is the same as NotImplements, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotKind ¶ added in v2.2.0

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

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 stops execution.

package main

import (
	"fmt"
	"reflect"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotKind(t, reflect.String, 0)
	fmt.Println("passed")

}

Output:

passed

func NotKindf ¶ added in v2.2.0

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

NotKindf is the same as NotKind, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotNil ¶

func NotNil(t T, object any, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotNil(t, "not nil")
	fmt.Println("passed")

}

Output:

passed

func NotNilf ¶

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

NotNilf is the same as NotNil, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotPanics ¶

func NotPanics(t T, f assertions.PanicTestFunc, msgAndArgs ...any)

NotPanics asserts that the code inside the specified PanicTestFunc 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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotPanics(t, func() {
	})
	fmt.Println("passed")

}

Output:

passed

func NotPanicsf ¶

func NotPanicsf(t T, f assertions.PanicTestFunc, msg string, args ...any)

NotPanicsf is the same as NotPanics, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotRegexp ¶

func NotRegexp(t T, rx any, actual any, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotRegexp(t, "^start", "not starting")
	fmt.Println("passed")

}

Output:

passed

func NotRegexpT ¶ added in v2.2.0

func NotRegexpT[Rex RegExp, ADoc Text](t T, rx Rex, actual ADoc, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotRegexpT(t, "^start", "not starting")
	fmt.Println("passed")

}

Output:

passed

func NotRegexpTf ¶ added in v2.2.0

func NotRegexpTf[Rex RegExp, ADoc Text](t T, rx Rex, actual ADoc, msg string, args ...any)

NotRegexpTf is the same as NotRegexpT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotRegexpf ¶

func NotRegexpf(t T, rx any, actual any, msg string, args ...any)

NotRegexpf is the same as NotRegexp, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotSame ¶

func NotSame(t T, expected any, actual any, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotSame(t, &staticVar, ptr("static string"))
	fmt.Println("passed")

}

//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:

passed

func NotSameT ¶ added in v2.2.0

func NotSameT[P any](t T, expected *P, actual *P, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotSameT(t, &staticVar, ptr("static string"))
	fmt.Println("passed")

}

//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:

passed

func NotSameTf ¶ added in v2.2.0

func NotSameTf[P any](t T, expected *P, actual *P, msg string, args ...any)

NotSameTf is the same as NotSameT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotSamef ¶

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

NotSamef is the same as NotSame, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotSortedT ¶ added in v2.2.0

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

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotSortedT(t, []int{3, 1, 3})
	fmt.Println("passed")

}

Output:

passed

func NotSortedTf ¶ added in v2.2.0

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

NotSortedTf is the same as NotSortedT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotSubset ¶

func NotSubset(t T, list any, subset any, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotSubset(t, []int{1, 2, 3}, []int{4, 5})
	fmt.Println("passed")

}

Output:

passed

func NotSubsetf ¶

func NotSubsetf(t T, list any, subset any, msg string, args ...any)

NotSubsetf is the same as NotSubset, but it accepts a format msg string to format arguments like fmt.Printf.

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

func NotZero ¶

func NotZero(t T, i any, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.NotZero(t, 1)
	fmt.Println("passed")

}

Output:

passed

func NotZerof ¶

func NotZerof(t T, i any, msg string, args ...any)

NotZerof is the same as NotZero, but it accepts a format msg string to format arguments like fmt.Printf.

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

func ObjectsAreEqual ¶ added in v2.1.0

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 ¶ added in v2.1.0

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 assertions.PanicTestFunc, msgAndArgs ...any)

Panics asserts that the code inside the specified PanicTestFunc panics.

Usage ¶

assertions.Panics(t, func(){ GoCrazy() })

Examples ¶

success: func() { panic("panicking") }
failure: func() { }

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Panics(t, func() {
		panic("panicking")
	})
	fmt.Println("passed")

}

Output:

passed

func PanicsWithError ¶

func PanicsWithError(t T, errString string, f assertions.PanicTestFunc, msgAndArgs ...any)

PanicsWithError asserts that the code inside the specified PanicTestFunc 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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.PanicsWithError(t, assert.ErrTest.Error(), func() {
		panic(assert.ErrTest)
	})
	fmt.Println("passed")

}

Output:

passed

func PanicsWithErrorf ¶

func PanicsWithErrorf(t T, errString string, f assertions.PanicTestFunc, msg string, args ...any)

PanicsWithErrorf is the same as PanicsWithError, but it accepts a format msg string to format arguments like fmt.Printf.

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

func PanicsWithValue ¶

func PanicsWithValue(t T, expected any, f assertions.PanicTestFunc, msgAndArgs ...any)

PanicsWithValue asserts that the code inside the specified PanicTestFunc 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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.PanicsWithValue(t, "panicking", func() {
		panic("panicking")
	})
	fmt.Println("passed")

}

Output:

passed

func PanicsWithValuef ¶

func PanicsWithValuef(t T, expected any, f assertions.PanicTestFunc, msg string, args ...any)

PanicsWithValuef is the same as PanicsWithValue, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Panicsf ¶

func Panicsf(t T, f assertions.PanicTestFunc, msg string, args ...any)

Panicsf is the same as Panics, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Positive ¶

func Positive(t T, e any, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Positive(t, 1)
	fmt.Println("passed")

}

Output:

passed

func PositiveT ¶ added in v2.2.0

func PositiveT[SignedNumber SignedNumeric](t T, e SignedNumber, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.PositiveT(t, 1)
	fmt.Println("passed")

}

Output:

passed

func PositiveTf ¶ added in v2.2.0

func PositiveTf[SignedNumber SignedNumeric](t T, e SignedNumber, msg string, args ...any)

PositiveTf is the same as PositiveT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Positivef ¶

func Positivef(t T, e any, msg string, args ...any)

Positivef is the same as Positive, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Regexp ¶

func Regexp(t T, rx any, actual any, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Regexp(t, "^start", "starting")
	fmt.Println("passed")

}

Output:

passed

func RegexpT ¶ added in v2.2.0

func RegexpT[Rex RegExp, ADoc Text](t T, rx Rex, actual ADoc, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.RegexpT(t, "^start", "starting")
	fmt.Println("passed")

}

Output:

passed

func RegexpTf ¶ added in v2.2.0

func RegexpTf[Rex RegExp, ADoc Text](t T, rx Rex, actual ADoc, msg string, args ...any)

RegexpTf is the same as RegexpT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Regexpf ¶

func Regexpf(t T, rx any, actual any, msg string, args ...any)

Regexpf is the same as Regexp, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Same ¶

func Same(t T, expected any, actual any, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Same(t, &staticVar, staticVarPtr)
	fmt.Println("passed")

}

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

Output:

passed

func SameT ¶ added in v2.2.0

func SameT[P any](t T, expected *P, actual *P, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.SameT(t, &staticVar, staticVarPtr)
	fmt.Println("passed")

}

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

Output:

passed

func SameTf ¶ added in v2.2.0

func SameTf[P any](t T, expected *P, actual *P, msg string, args ...any)

SameTf is the same as SameT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Samef ¶

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

Samef is the same as Same, but it accepts a format msg string to format arguments like fmt.Printf.

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

func SeqContainsT ¶ added in v2.2.0

func SeqContainsT[E comparable](t T, iter iter.Seq[E], element E, msgAndArgs ...any)

SeqContainsT asserts that the specified iterator contains a comparable element.

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 stops execution.

package main

import (
	"fmt"
	"slices"
	"testing"

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

func main() {
	t := new(testing.T)
	require.SeqContainsT(t, slices.Values([]string{"A", "B"}), "A")
	fmt.Println("passed")

}

Output:

passed

func SeqContainsTf ¶ added in v2.2.0

func SeqContainsTf[E comparable](t T, iter iter.Seq[E], element E, msg string, args ...any)

SeqContainsTf is the same as SeqContainsT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func SeqNotContainsT ¶ added in v2.2.0

func SeqNotContainsT[E comparable](t T, iter iter.Seq[E], element E, msgAndArgs ...any)

SeqNotContainsT asserts that the specified iterator does not contain a comparable element.

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 stops execution.

package main

import (
	"fmt"
	"slices"
	"testing"

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

func main() {
	t := new(testing.T)
	require.SeqNotContainsT(t, slices.Values([]string{"A", "B"}), "C")
	fmt.Println("passed")

}

Output:

passed

func SeqNotContainsTf ¶ added in v2.2.0

func SeqNotContainsTf[E comparable](t T, iter iter.Seq[E], element E, msg string, args ...any)

SeqNotContainsTf is the same as SeqNotContainsT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func SliceContainsT ¶ added in v2.2.0

func SliceContainsT[Slice ~[]E, E comparable](t T, s Slice, element E, msgAndArgs ...any)

SliceContainsT asserts that the specified slice contains a comparable element.

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.SliceContainsT(t, []string{"A", "B"}, "A")
	fmt.Println("passed")

}

Output:

passed

func SliceContainsTf ¶ added in v2.2.0

func SliceContainsTf[Slice ~[]E, E comparable](t T, s Slice, element E, msg string, args ...any)

SliceContainsTf is the same as SliceContainsT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func SliceNotContainsT ¶ added in v2.2.0

func SliceNotContainsT[Slice ~[]E, E comparable](t T, s Slice, element E, msgAndArgs ...any)

SliceNotContainsT asserts that the specified slice does not contain a comparable element.

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.SliceNotContainsT(t, []string{"A", "B"}, "C")
	fmt.Println("passed")

}

Output:

passed

func SliceNotContainsTf ¶ added in v2.2.0

func SliceNotContainsTf[Slice ~[]E, E comparable](t T, s Slice, element E, msg string, args ...any)

SliceNotContainsTf is the same as SliceNotContainsT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func SliceNotSubsetT ¶ added in v2.2.0

func SliceNotSubsetT[Slice ~[]E, E comparable](t T, list Slice, subset Slice, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.SliceNotSubsetT(t, []int{1, 2, 3}, []int{4, 5})
	fmt.Println("passed")

}

Output:

passed

func SliceNotSubsetTf ¶ added in v2.2.0

func SliceNotSubsetTf[Slice ~[]E, E comparable](t T, list Slice, subset Slice, msg string, args ...any)

SliceNotSubsetTf is the same as SliceNotSubsetT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func SliceSubsetT ¶ added in v2.2.0

func SliceSubsetT[Slice ~[]E, E comparable](t T, list Slice, subset Slice, msgAndArgs ...any)

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.SliceSubsetT(t, []int{1, 2, 3}, []int{1, 2})
	fmt.Println("passed")

}

Output:

passed

func SliceSubsetTf ¶ added in v2.2.0

func SliceSubsetTf[Slice ~[]E, E comparable](t T, list Slice, subset Slice, msg string, args ...any)

SliceSubsetTf is the same as SliceSubsetT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func SortedT ¶ added in v2.2.0

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

SortedT asserts that the slice of Ordered is sorted (i.e. non-strictly increasing).

Unlike IsIncreasingT, it accepts elements to be equal.

Usage ¶

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

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.SortedT(t, []int{1, 1, 3})
	fmt.Println("passed")

}

Output:

passed

func SortedTf ¶ added in v2.2.0

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

SortedTf is the same as SortedT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func StringContainsT ¶ added in v2.2.0

func StringContainsT[ADoc, EDoc Text](t T, str ADoc, substring EDoc, msgAndArgs ...any)

StringContainsT asserts that a string contains the specified substring.

Strings may be go strings or []byte.

Usage ¶

assertions.StringContainsT(t, "Hello World", "World")

Examples ¶

success: "AB", "A"
failure: "AB", "C"

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.StringContainsT(t, "AB", "A")
	fmt.Println("passed")

}

Output:

passed

func StringContainsTf ¶ added in v2.2.0

func StringContainsTf[ADoc, EDoc Text](t T, str ADoc, substring EDoc, msg string, args ...any)

StringContainsTf is the same as StringContainsT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func StringNotContainsT ¶ added in v2.2.0

func StringNotContainsT[ADoc, EDoc Text](t T, str ADoc, substring EDoc, msgAndArgs ...any)

StringNotContainsT asserts that a string does not contain the specified substring.

Strings may be go strings or []byte.

Usage ¶

assertions.StringNotContainsT(t, "Hello World", "hi")

Examples ¶

success: "AB", "C"
failure: "AB", "A"

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.StringNotContainsT(t, "AB", "C")
	fmt.Println("passed")

}

Output:

passed

func StringNotContainsTf ¶ added in v2.2.0

func StringNotContainsTf[ADoc, EDoc Text](t T, str ADoc, substring EDoc, msg string, args ...any)

StringNotContainsTf is the same as StringNotContainsT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Subset ¶

func Subset(t T, list any, subset any, msgAndArgs ...any)

Subset asserts that the list (array, slice, or map) contains 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.Subset(t, []int{1, 2, 3}, []int{1, 2})
assertions.Subset(t, []string{"x": 1, "y": 2}, []string{"x": 1})
assertions.Subset(t, []int{1, 2, 3}, map[int]string{1: "one", 2: "two"})
assertions.Subset(t, map[string]int{"x": 1, "y": 2}, []string{"x"})

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 stops execution.

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Subset(t, []int{1, 2, 3}, []int{1, 2})
	fmt.Println("passed")

}

Output:

passed

func Subsetf ¶

func Subsetf(t T, list any, subset any, msg string, args ...any)

Subsetf is the same as Subset, but it accepts a format msg string to format arguments like fmt.Printf.

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

func True ¶

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

True asserts that the specified value is true.

Usage ¶

assertions.True(t, myBool)

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.True(t, 1 == 1)
	fmt.Println("passed")

}

Output:

passed

func TrueT ¶ added in v2.2.0

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

TrueT asserts that the specified value is true.

Usage ¶

type B bool
var b B = true

assertions.True(t, b)

Examples ¶

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

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.TrueT(t, 1 == 1)
	fmt.Println("passed")

}

Output:

passed

func TrueTf ¶ added in v2.2.0

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

TrueTf is the same as TrueT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Truef ¶

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

Truef is the same as True, but it accepts a format msg string to format arguments like fmt.Printf.

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

func WithinDuration ¶

func WithinDuration(t T, expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...any)

WithinDuration asserts that the two times are within duration delta of each other.

Usage ¶

assertions.WithinDuration(t, time.Now(), 10*time.Second)

Examples ¶

success: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 12, 0, 1, 0, time.UTC), 2*time.Second
failure: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 12, 0, 10, 0, time.UTC), 1*time.Second

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

package main

import (
	"fmt"
	"testing"
	"time"

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

func main() {
	t := new(testing.T)
	require.WithinDuration(t, time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 12, 0, 1, 0, time.UTC), 2*time.Second)
	fmt.Println("passed")

}

Output:

passed

func WithinDurationf ¶

func WithinDurationf(t T, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...any)

WithinDurationf is the same as WithinDuration, but it accepts a format msg string to format arguments like fmt.Printf.

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

func WithinRange ¶

func WithinRange(t T, actual time.Time, start time.Time, end time.Time, msgAndArgs ...any)

WithinRange asserts that a time is within a time range (inclusive).

Usage ¶

assertions.WithinRange(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))

Examples ¶

success: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 11, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 13, 0, 0, 0, time.UTC)
failure: time.Date(2024, 1, 1, 14, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 11, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 13, 0, 0, 0, time.UTC)

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

package main

import (
	"fmt"
	"testing"
	"time"

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

func main() {
	t := new(testing.T)
	require.WithinRange(t, time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 11, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 13, 0, 0, 0, time.UTC))
	fmt.Println("passed")

}

Output:

passed

func WithinRangef ¶

func WithinRangef(t T, actual time.Time, start time.Time, end time.Time, msg string, args ...any)

WithinRangef is the same as WithinRange, but it accepts a format msg string to format arguments like fmt.Printf.

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

func YAMLEq ¶

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

YAMLEq asserts that two YAML strings are equivalent.

See YAMLEqBytes.

Examples ¶

panic: "key: value", "key: value"
should panic without the yaml feature enabled.

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

func YAMLEqBytes ¶ added in v2.2.0

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

YAMLEqBytes asserts that two YAML slices of bytes are equivalent.

Expected and actual must be valid YAML.

Important ¶

By default, this function is disabled and will panic.

To enable it, you should add a blank import like so:

import(
  "github.com/go-openapi/testify/enable/yaml/v2"
)

Usage ¶

expected := `---
key: value
---
key: this is a second document, it is not evaluated
`
actual := `---
key: value
---
key: this is a subsequent document, it is not evaluated
`
assertions.YAMLEq(t, expected, actual)

Examples ¶

panic: []byte("key: value"), []byte("key: value")
should panic without the yaml feature enabled.

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

func YAMLEqBytesf ¶ added in v2.2.0

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

YAMLEqBytesf is the same as YAMLEqBytes, but it accepts a format msg string to format arguments like fmt.Printf.

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

func YAMLEqT ¶ added in v2.2.0

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

YAMLEqT asserts that two YAML documents are equivalent.

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

See YAMLEqBytes.

Examples ¶

panic: "key: value", "key: value"
should panic without the yaml feature enabled.

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

func YAMLEqTf ¶ added in v2.2.0

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

YAMLEqTf is the same as YAMLEqT, but it accepts a format msg string to format arguments like fmt.Printf.

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

func YAMLEqf ¶

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

YAMLEqf is the same as YAMLEq, but it accepts a format msg string to format arguments like fmt.Printf.

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

func Zero ¶

func Zero(t T, i any, msgAndArgs ...any)

Zero asserts that i is the zero value for its type.

Usage ¶

assertions.Zero(t, obj)

Examples ¶

success: 0
failure: 1

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

package main

import (
	"fmt"
	"testing"

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

func main() {
	t := new(testing.T)
	require.Zero(t, 0)
	fmt.Println("passed")

}

Output:

passed

func Zerof ¶

func Zerof(t T, i any, msg string, args ...any)

Zerof is the same as Zero, but it accepts a format msg string to format arguments like fmt.Printf.

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